@eodash/eodash 5.0.0-alpha.2.9 → 5.0.0-processing

package/dist/client/EodashLayerControl-53WghA8G.js

@@ -0,0 +1,110 @@
+import { computed, ref, openBlock, createElementBlock, unref, createCommentVNode } from 'vue';
+import '@eox/layercontrol';
+import '@eox/jsonform';
+import '@eox/timecontrol';
+import 'color-legend-element';
+import { a0 as useSTAcStore, a3 as mapCompareEl, a4 as mapEl, a5 as eodashCompareCollections, a1 as eodashCollections, a6 as getColFromLayer } from './asWebComponent-DUUoR7MZ.js';
+import { storeToRefs } from 'pinia';
+
+const _hoisted_1 = { class: "d-flex flex-column fill-height overflow-auto" };
+const _hoisted_2 = ["for"];
+
+
+const _sfc_main = {
+  __name: 'EodashLayerControl',
+  props: {
+  map: {
+    type: String,
+    default: "first",
+  },
+},
+  setup(__props) {
+
+const props = __props;
+
+const { selectedCompareStac, selectedStac } = storeToRefs(useSTAcStore());
+
+const showControls = computed(() => {
+  if (props.map === "second") {
+    return mapCompareEl.value !== null && selectedCompareStac.value !== null;
+  }
+  return mapEl.value !== null && selectedStac.value !== null;
+});
+
+const eodashCols =
+  props.map === "second" ? eodashCompareCollections : eodashCollections;
+const mapElement = props.map === "second" ? mapCompareEl : mapEl;
+
+/** @type { import("vue").Ref<HTMLElement & Record<string,any> | null>} */
+const eoxLayercontrol = ref(null);
+
+/** @param {CustomEvent<{layer:import('ol/layer').Layer; datetime:string;}>} evt */
+const handleDatetimeUpdate = async (evt) => {
+  const { layer, datetime } = evt.detail;
+
+  const ec = await getColFromLayer(eodashCols, layer);
+
+  /** @type {Record<string,any>[] | undefined} */
+  let updatedLayers = [];
+
+  if (ec) {
+    await ec.fetchCollection();
+    updatedLayers = await ec.updateLayerJson(
+      datetime,
+      layer.get("id"),
+      props.map,
+    );
+  }
+  /** @type {Record<String,any>[] | undefined} */
+  const dataLayers = updatedLayers?.find(
+    (l) => l?.properties?.id === "AnalysisGroup",
+  )?.layers;
+
+  if (dataLayers?.length) {
+    // Add expand to all analysis layers
+    dataLayers?.forEach((dl) => {
+      dl.properties.layerControlExpand = true;
+      dl.properties.layerControlToolsExpand = true;
+    });
+    // assign layers to the map
+    /** @type {HTMLElement & Record<string,any>} */
+    (mapElement.value).layers = updatedLayers;
+  }
+};
+
+// -----  debounce logic
+/** @type {NodeJS.Timeout | undefined} */
+let timeout;
+
+/**
+ * @param {CustomEvent<{layer:import('ol/layer').Layer; datetime:string;}>} evt
+ **/
+const debouncedHandleDateTime = (evt) => {
+  clearTimeout(timeout);
+  timeout = setTimeout(() => {
+    handleDatetimeUpdate(evt);
+  }, 500);
+};
+// ------
+
+return (_ctx, _cache) => {
+  return (openBlock(), createElementBlock("span", _hoisted_1, [
+    (showControls.value)
+      ? (openBlock(), createElementBlock("eox-layercontrol", {
+          key: 0,
+          for: unref(mapElement),
+          ".tools": ['datetime', 'info', 'config', 'legend', 'opacity'],
+          "onDatetime:updated": debouncedHandleDateTime,
+          class: "fill-height",
+          toolsAsList: "true",
+          ref_key: "eoxLayercontrol",
+          ref: eoxLayercontrol
+        }, null, 40 /* PROPS, NEED_HYDRATION */, _hoisted_2))
+      : createCommentVNode("v-if", true)
+  ]))
+}
+}
+
+};
+
+export { _sfc_main as default };

package/dist/client/EodashMap-CQnOePpy.js

@@ -0,0 +1,486 @@
+import { onMounted, onUnmounted, watch, nextTick, ref, computed, openBlock, createElementBlock, createElementVNode } from 'vue';
+import '@eox/map';
+import '@eox/map/src/plugins/advancedLayersAndSources';
+import { a7 as eoxLayersKey, a0 as useSTAcStore, a8 as setMapProjFromCol, a9 as EodashCollection, aa as mapPosition, a4 as mapEl, a3 as mapCompareEl, $ as datetime, a5 as eodashCompareCollections, a1 as eodashCollections } from './asWebComponent-DUUoR7MZ.js';
+import { storeToRefs } from 'pinia';
+import log from 'loglevel';
+import { useEventBus } from '@vueuse/core';
+
+/**
+ * Holder for previous compare map view as it is overwritten by sync
+ * @type { {map:import("ol").View } | null} mapElement
+ */
+let viewHolder = null;
+
+/**
+ * Description placeholder
+ *
+ * @param {import("vue").Ref<HTMLElement & Record<string,any> & {map:import("ol").Map } | null>} mapElement
+ * @param {import("vue").Ref<(number | undefined)[]>} mapPosition
+ */
+const useHandleMapMoveEnd = (mapElement, mapPosition) => {
+  /** @type {import("openlayers").EventsListenerFunctionType} */
+  const handleMoveEnd = (evt) => {
+    const map = /** @type {import("openlayers").Map | undefined} */ (
+      /** @type {any} */ (evt).map
+    );
+    const lonlat = mapElement.value?.lonLatCenter;
+    const z = map?.getView().getZoom();
+    if (
+      lonlat &&
+      !Number.isNaN(lonlat[0]) &&
+      !Number.isNaN(lonlat[1]) &&
+      !Number.isNaN(z)
+    ) {
+      mapPosition.value = [lonlat[0], lonlat[1], z];
+    }
+  };
+
+  onMounted(() => {
+    /** @type {import('ol/Map').default} */
+    (mapElement.value?.map)?.on("moveend", handleMoveEnd);
+  });
+
+  onUnmounted(() => {
+    /** @type {import('ol/Map').default} */
+    (mapElement.value?.map)?.un("moveend", handleMoveEnd);
+  });
+};
+
+/**
+ * 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} [updatedTime]
+ */
+
+const createLayersConfig = async (
+  selectedIndicator,
+  eodashCols,
+  updatedTime,
+) => {
+  log.debug(
+    "Creating layers config",
+    selectedIndicator,
+    eodashCols,
+    updatedTime,
+  );
+  const layersCollection = [];
+  const dataLayers = {
+    type: "Group",
+    properties: {
+      id: "AnalysisGroup",
+      title: "Analysis Layers",
+      layerControlExpand: true,
+    },
+    layers: /** @type {Record<string,any>[]}*/ ([]),
+  };
+
+  for (const ec of eodashCols) {
+    let layers;
+    if (updatedTime) {
+      layers = await ec.createLayersJson(new Date(updatedTime));
+    } else {
+      layers = await ec.createLayersJson();
+    }
+    // Add expand to all analysis layers
+    layers.forEach((dl) => {
+      dl.properties.layerControlExpand = true;
+      dl.properties.layerControlToolsExpand = true;
+    });
+    dataLayers.layers.push(...layers);
+  }
+
+  layersCollection.push(dataLayers);
+  const indicatorLayers =
+    //@ts-expect-error indicator is collection
+    await EodashCollection.getIndicatorLayers(selectedIndicator);
+
+  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.push(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.unshift(overlayLayers);
+  }
+
+  return layersCollection;
+};
+
+/**
+ * Description placeholder
+ *
+ * @param {import("vue").Ref<HTMLElement & Record<string,any> | null>} mapElement
+ * @param {import("vue").Ref<import("stac-ts").StacCollection | null>} selectedIndicator
+ * @param {EodashCollection[]} eodashCols
+ * @param {import("vue").Ref<string>} datetime
+ * @param {import("vue").Ref<Record<string,any>[]>} mapLayers
+ * @param {import("vue").Ref<HTMLElement & Record<string,any> | null>} partnerMap
+ */
+const useInitMap = (
+  mapElement,
+  selectedIndicator,
+  eodashCols,
+  datetime,
+  mapLayers,
+  partnerMap,
+) => {
+  log.debug(
+    "InitMap",
+    mapElement.value,
+    selectedIndicator.value,
+    eodashCols.values,
+    datetime.value,
+  );
+  const layersEvent = useEventBus(eoxLayersKey);
+
+  const stopIndicatorWatcher = watch(
+    [selectedIndicator, datetime],
+    async ([updatedStac, updatedTime], [previousStac, previousTime]) => {
+      if (updatedStac) {
+        log.debug(
+          "Selected Indicator watch triggered",
+          updatedStac,
+          updatedTime,
+        );
+
+        if (mapElement?.value?.id === "main") {
+          // Making sure main map gets the viewer that seems to be
+          // removed when the second map is no longer rendered
+          if (viewHolder !== null) {
+            // Set view to previous compare view
+            mapElement?.value?.map.setView(viewHolder);
+            viewHolder = null;
+          }
+        }
+        let layersCollection = [];
+
+        const onlyTimeChanged =
+          updatedStac?.id === previousStac?.id && updatedTime !== previousTime;
+
+        const { selectedCompareStac } = storeToRefs(useSTAcStore());
+        if (mapElement?.value?.id === "main") {
+          // Main map being initialized
+          // Set projection based on indicator level information for both maps
+          await setMapProjFromCol(updatedStac);
+        } else {
+          // Compare map being initialized
+          if (selectedCompareStac.value !== null) {
+            // save view of compare map
+            viewHolder = mapElement?.value?.map.getView();
+            /** @type {any} */
+            (mapElement.value).sync = partnerMap.value;
+          }
+        }
+
+        // We re-crate the configuration if time changed
+        if (onlyTimeChanged) {
+          layersCollection = await createLayersConfig(
+            updatedStac,
+            eodashCols,
+            updatedTime,
+          );
+          log.debug(
+            "Assigned layers after changing time only",
+            JSON.parse(JSON.stringify(layersCollection)),
+          );
+          mapLayers.value = layersCollection;
+          await nextTick(() => {
+            layersEvent.emit("time:updated", mapLayers.value);
+          });
+          return;
+        }
+
+        /** @type {Record<string,any>[]} */
+        layersCollection = await createLayersConfig(
+          updatedStac,
+          eodashCols,
+          datetime.value,
+        );
+
+        // We try to set the current time selection to latest extent date
+        let endInterval = null;
+        const interval = updatedStac?.extent?.temporal?.interval;
+        if (interval && interval.length > 0 && interval[0].length > 1) {
+          // @ts-expect-error this is the defined STAC structure
+          endInterval = new Date(interval[0][1]);
+          log.debug(
+            "Indicator load: found stac extent, setting time to latest value",
+            endInterval,
+          );
+        }
+        if (
+          endInterval !== null &&
+          endInterval.toISOString() !== datetime.value
+        ) {
+          datetime.value = endInterval.toISOString();
+        }
+
+        // Try to move map view to extent only when main
+        // indicator and map changes
+        if (
+          mapElement?.value?.id === "main" &&
+          updatedStac.extent?.spatial.bbox
+        ) {
+          // Sanitize extent,
+          const b = updatedStac.extent?.spatial.bbox[0];
+          const sanitizedExtent = [
+            b[0] > -180 ? b[0] : -180,
+            b[1] > -90 ? b[1] : -90,
+            b[2] < 180 ? b[2] : 180,
+            b[3] < 90 ? b[3] : 90,
+          ];
+
+          const reprojExtent = mapElement.value?.transformExtent(
+            sanitizedExtent,
+            "EPSG:4326",
+            mapElement.value?.map?.getView().getProjection(),
+          );
+          /** @type {any} */
+          (mapElement.value).zoomExtent = reprojExtent;
+        }
+
+        log.debug(
+          "Assigned layers",
+          JSON.parse(JSON.stringify(layersCollection)),
+        );
+
+        mapLayers.value = layersCollection;
+        // Emit event to update layers
+        await nextTick(() => {
+          mapElement.value?.updateComplete.then(() => {
+            layersEvent.emit("layers:updated", mapLayers.value);
+          });
+        });
+      }
+    },
+    { immediate: true },
+  );
+
+  onUnmounted(() => {
+    stopIndicatorWatcher();
+  });
+};
+
+const _hoisted_1 = [".enabled"];
+const _hoisted_2 = [".layers"];
+const _hoisted_3 = [".layers"];
+
+
+const _sfc_main = {
+  __name: 'EodashMap',
+  props: {
+  enableCompare: {
+    type: Boolean,
+    default: false,
+  },
+},
+  setup(__props) {
+
+const props = __props;
+
+/** @type {import("vue").Ref<Record<string,any>[]>} */
+const eoxMapLayers = ref([
+  {
+    type: "Tile",
+    source: { type: "OSM" },
+    properties: {
+      id: "osm",
+      title: "Background",
+    },
+  },
+]);
+
+/** @type {import("vue").Ref<Record<string,any>[]>} */
+const eoxMapCompareLayers = ref([
+  {
+    type: "Tile",
+    source: { type: "OSM" },
+    properties: {
+      id: "osm",
+      title: "Background",
+    },
+  },
+]);
+
+/** @type {import("vue").Ref<(HTMLElement & Record<string,any> & { map:import("ol").Map }) | null>} */
+const eoxMap = ref(null);
+/** @type {import("vue").Ref<(HTMLElement & Record<string,any> & { map:import("ol").Map }) | null>} */
+const compareMap = ref(null);
+
+const eoxMapConfig = {
+  /** @type {(number|undefined)[] | undefined} */
+  center: [15, 48],
+  /** @type {number | undefined} */
+  zoom: 4,
+};
+
+const eoxCompareMapConfig = {
+  /** @type {(number|undefined)[] | undefined} */
+  center: [15, 48],
+  /** @type {number | undefined} */
+  zoom: 4,
+};
+
+// Check if selected indicator was already set in store
+if (mapPosition && mapPosition.value && mapPosition.value.length === 3) {
+  // TODO: do further checks for invalid values?
+  // TODO: can we expect the values to be in a specific projection
+  eoxMapConfig.center = [mapPosition.value?.[0], mapPosition.value[1]];
+  eoxMapConfig.zoom = mapPosition.value[2];
+}
+const { selectedCompareStac } = storeToRefs(useSTAcStore());
+const showCompare = computed(() =>
+  props.enableCompare && !!selectedCompareStac.value ? "" : "first",
+);
+
+useHandleMapMoveEnd(eoxMap, mapPosition);
+
+onMounted(() => {
+  const { selectedCompareStac, selectedStac } = storeToRefs(useSTAcStore());
+  // assign map Element state to eox map
+  mapEl.value = eoxMap.value;
+
+  if (props.enableCompare) {
+    mapCompareEl.value = compareMap.value;
+  }
+
+  if (props.enableCompare) {
+    useInitMap(
+      compareMap,
+      //@ts-expect-error todo selectedStac as collection
+      selectedCompareStac,
+      eodashCompareCollections,
+      datetime,
+      eoxMapCompareLayers,
+      eoxMap,
+    );
+  }
+
+  useInitMap(
+    eoxMap,
+    //@ts-expect-error todo selectedStac as collection
+    selectedStac,
+    eodashCollections,
+    datetime,
+    eoxMapLayers,
+    compareMap,
+  );
+});
+
+return (_ctx, _cache) => {
+  return (openBlock(), createElementBlock("eox-map-compare", {
+    class: "fill-height fill-width overflow-none",
+    ".enabled": showCompare.value
+  }, [
+    createElementVNode("eox-map", {
+      class: "fill-height fill-width overflow-none",
+      slot: "first",
+      ref_key: "eoxMap",
+      ref: eoxMap,
+      ".config": eoxMapConfig,
+      id: "main",
+      ".layers": eoxMapLayers.value
+    }, null, 40 /* PROPS, NEED_HYDRATION */, _hoisted_2),
+    createElementVNode("eox-map", {
+      class: "fill-height fill-width overflow-none",
+      id: "compare",
+      slot: "second",
+      ref_key: "compareMap",
+      ref: compareMap,
+      ".config": eoxCompareMapConfig,
+      ".layers": eoxMapCompareLayers.value
+    }, null, 40 /* PROPS, NEED_HYDRATION */, _hoisted_3)
+  ], 40 /* PROPS, NEED_HYDRATION */, _hoisted_1))
+}
+}
+
+};
+
+export { _sfc_main as default };

package/dist/client/EodashMapBtns-uaRwFtfB.js

@@ -0,0 +1,66 @@
+import { ref, openBlock, createElementBlock, createBlock, unref, createCommentVNode } from 'vue';
+import { _ as _export_sfc, ab as makePanelTransparent, V as VBtn, ac as availableMapProjection, ad as changeMapProjection } from './asWebComponent-DUUoR7MZ.js';
+import { mdiMapPlus, mdiEarthBox } from '@mdi/js';
+import ExportState from './ExportState-BT8MLAW7.js';
+
+const _sfc_main = {
+  __name: 'EodashMapBtns',
+  props: {
+  exportMap: {
+    type: Boolean,
+    default: true,
+  },
+  changeProjection: {
+    type: Boolean,
+    default: true,
+  },
+},
+  setup(__props) {
+
+
+
+const showMapState = ref(false);
+
+/** @type {import("vue").Ref<HTMLDivElement|null>} */
+const rootRef = ref(null);
+makePanelTransparent(rootRef);
+
+return (_ctx, _cache) => {
+                                                     
+
+  return (openBlock(), createElementBlock("div", {
+    ref_key: "rootRef",
+    ref: rootRef,
+    class: "d-flex flex-column align-end justify-end my-3 pa-2"
+  }, [
+    (__props.exportMap)
+      ? (openBlock(), createBlock(VBtn, {
+          key: 0,
+          class: "map-btn",
+          icon: [unref(mdiMapPlus)],
+          onClick: _cache[0] || (_cache[0] = $event => (showMapState.value = !showMapState.value))
+        }, null, 8 /* PROPS */, ["icon"]))
+      : createCommentVNode("v-if", true),
+    (__props.exportMap)
+      ? (openBlock(), createBlock(ExportState, {
+          key: 1,
+          modelValue: showMapState.value,
+          "onUpdate:modelValue": _cache[1] || (_cache[1] = $event => ((showMapState).value = $event))
+        }, null, 8 /* PROPS */, ["modelValue"]))
+      : createCommentVNode("v-if", true),
+    (__props.changeProjection && !!unref(availableMapProjection))
+      ? (openBlock(), createBlock(VBtn, {
+          key: 2,
+          class: "map-btn",
+          icon: [unref(mdiEarthBox)],
+          onClick: _cache[2] || (_cache[2] = $event => (unref(changeMapProjection)(unref(availableMapProjection))))
+        }, null, 8 /* PROPS */, ["icon"]))
+      : createCommentVNode("v-if", true)
+  ], 512 /* NEED_PATCH */))
+}
+}
+
+};
+const EodashMapBtns = /*#__PURE__*/_export_sfc(_sfc_main, [['__scopeId',"data-v-d7a01370"]]);
+
+export { EodashMapBtns as default };