@eodash/eodash 5.0.0-rc.2.5 → 5.0.0

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

@@ -0,0 +1,54 @@
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any>|undefined} jsonformValue
+ * @param {number[]} origBbox
+ */
+export function processImage(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, origBbox: number[]): {
+    type: string;
+    properties: {
+        id: unknown;
+        title: string;
+    };
+    source: {
+        type: string;
+        imageExtent: number[];
+        url: string;
+    };
+}[] | undefined;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {string} layerId
+ */
+export function processVector(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, layerId: string): Promise<Record<string, any>[] | undefined>;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {string} specUrl
+ * @returns {Promise<[import("@eox/chart").EOxChart["spec"] | null,Record<string,any>|null]>}
+ **/
+export function getChartValues(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, specUrl: string): Promise<[import("@eox/chart").EOxChart["spec"] | null, Record<string, any> | null]>;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {import("vue").Ref<boolean>} isPolling
+ * @param {string} layerId
+ * @param {string} projection
+ */
+export function processGeoTiff(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, layerId: string, isPolling: import("vue").Ref<boolean>, projection: string): Promise<{
+    style?: Record<string, any> | undefined;
+    type: string;
+    source: {
+        type: string;
+        normalize: boolean;
+        sources: {
+            url: string;
+        }[];
+    };
+    properties: {
+        layerControlToolsExpand: boolean;
+        layerConfig?: Record<string, any> | undefined;
+        id: string;
+        title: string;
+    };
+} | undefined>;

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

@@ -0,0 +1,42 @@
+/**
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+export function getBboxProperty(jsonformSchema?: Record<string, any> | null): string;
+/**
+ * Extracts the keys of type "geojson" from the jsonform schema
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+export function getGeoJsonProperties(jsonformSchema?: Record<string, any> | null): string[];
+/**
+ * Converts jsonform geojson values to stringified geometries
+ * @param {Record<string,any> |null} [jsonformSchema]
+ * @param {Record<string,any>} jsonformValue
+ **/
+export function extractGeometries(jsonformValue: Record<string, any>, jsonformSchema?: Record<string, any> | null): void;
+/**
+ *
+ * @param {*} link
+ * @param {*} layerId
+ * @param {string[]} urls
+ * @param {*} projection
+ * @param {*} processId
+ * @returns
+ */
+export function createLayerDefinition(link: any, layerId: any, urls: string[], projection: any, processId: any): Promise<{
+    style?: Record<string, any> | undefined;
+    type: string;
+    source: {
+        type: string;
+        normalize: boolean;
+        sources: {
+            url: string;
+        }[];
+    };
+    properties: {
+        layerControlToolsExpand: boolean;
+        layerConfig?: Record<string, any> | undefined;
+        id: string;
+        title: string;
+    };
+} | undefined>;
+export function download(fileName: string, content: string | Record<string, any>): void;

package/dist/types/widgets/EodashStacInfo.vue.d.ts

@@ -1,21 +1,21 @@
 declare const _default: import("vue").DefineComponent<{}, {
-    body: unknown[];
+    body: string[];
     styleOverride: string;
-    tags: unknown[];
-    header: unknown[];
-    footer: unknown[];
-    featured: unknown[];
     allowHtml: boolean;
-    subheader: unknown[];
+    header: string[];
+    tags: string[];
+    subheader: string[];
+    featured: string[];
+    footer: string[];
     $props: {
-        readonly body?: unknown[] | undefined;
+        readonly body?: string[] | undefined;
         readonly styleOverride?: string | undefined;
-        readonly tags?: unknown[] | undefined;
-        readonly header?: unknown[] | undefined;
-        readonly footer?: unknown[] | undefined;
-        readonly featured?: unknown[] | undefined;
         readonly allowHtml?: boolean | undefined;
-        readonly subheader?: unknown[] | undefined;
+        readonly header?: string[] | undefined;
+        readonly tags?: string[] | undefined;
+        readonly subheader?: string[] | undefined;
+        readonly featured?: string[] | undefined;
+        readonly footer?: string[] | undefined;
     };
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/types/widgets/EodashTools.vue.d.ts

@@ -1,17 +1,55 @@
 declare const _default: import("vue").DefineComponent<{}, {
+    showIndicatorsBtn: boolean;
+    showLayoutSwitcher: boolean;
     layoutTarget: string;
     layoutIcon: string;
-    itemFilterConfig: Record<string, any>;
-    showLayoutSwitcher: boolean;
     indicatorBtnText: string;
-    showIndicatorsBtn: boolean;
+    itemFilterConfig: Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never> & {
+        readonly enableCompare?: boolean | undefined;
+        readonly filtersTitle?: string | undefined;
+        readonly resultsTitle?: string | undefined;
+        readonly titleProperty?: string | undefined;
+        readonly imageProperty?: string | undefined;
+        readonly subTitleProperty?: string | undefined;
+        readonly resultType?: string | undefined;
+        readonly cssVars?: string | Record<string, any> | undefined;
+        readonly enableHighlighting?: boolean | undefined;
+        readonly expandMultipleFilters?: boolean | undefined;
+        readonly expandMultipleResults?: boolean | undefined;
+        readonly filterProperties?: {
+            keys: string[];
+            title: string;
+            type: string;
+            expanded?: boolean;
+        }[] | undefined;
+        readonly aggregateResults?: string | undefined;
+    };
     $props: {
+        readonly showIndicatorsBtn?: boolean | undefined;
+        readonly showLayoutSwitcher?: boolean | undefined;
         readonly layoutTarget?: string | undefined;
         readonly layoutIcon?: string | undefined;
-        readonly itemFilterConfig?: Record<string, any> | undefined;
-        readonly showLayoutSwitcher?: boolean | undefined;
         readonly indicatorBtnText?: string | undefined;
-        readonly showIndicatorsBtn?: boolean | undefined;
+        readonly itemFilterConfig?: (Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never> & {
+            readonly enableCompare?: boolean | undefined;
+            readonly filtersTitle?: string | undefined;
+            readonly resultsTitle?: string | undefined;
+            readonly titleProperty?: string | undefined;
+            readonly imageProperty?: string | undefined;
+            readonly subTitleProperty?: string | undefined;
+            readonly resultType?: string | undefined;
+            readonly cssVars?: string | Record<string, any> | undefined;
+            readonly enableHighlighting?: boolean | undefined;
+            readonly expandMultipleFilters?: boolean | undefined;
+            readonly expandMultipleResults?: boolean | undefined;
+            readonly filterProperties?: {
+                keys: string[];
+                title: string;
+                type: string;
+                expanded?: boolean;
+            }[] | undefined;
+            readonly aggregateResults?: string | undefined;
+        }) | undefined;
     };
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
     rootEl: HTMLDivElement;

package/dist/types/widgets/PopUp.vue.d.ts

@@ -4,16 +4,16 @@ type __VLS_WithTemplateSlots<T, S> = T & (new () => {
     $slots: S;
 });
 declare const __VLS_component: import("vue").DefineComponent<{}, {
+    maxWidth: string;
+    maxHeight: string;
     width: string;
     height: string;
-    maxHeight: string;
-    maxWidth: string;
     widget?: import("../core/client/types").Widget<"compiletime"> | undefined;
     $props: {
+        readonly maxWidth?: string | undefined;
+        readonly maxHeight?: string | undefined;
         readonly width?: string | undefined;
         readonly height?: string | undefined;
-        readonly maxHeight?: string | undefined;
-        readonly maxWidth?: string | undefined;
         readonly widget?: import("../core/client/types").Widget<"compiletime"> | undefined;
     };
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLSpanElement>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eodash/eodash",
-  "version": "5.0.0-rc.2.5",
+  "version": "5.0.0",
   "type": "module",
   "types": "./dist/types/core/client/types.d.ts",
   "files": [
@@ -56,65 +56,65 @@
     "docs:dev": "vitepress dev docs --port 3333",
     "docs:build": "npm run docs:generate && vitepress build docs",
     "docs:preview": "vitepress preview docs",
-    "docs:generate": "typedoc --options typedoc.config.json"
+    "docs:generate": "npm run build:cli && npm run build:types && typedoc --options typedoc.config.json"
   },
   "dependencies": {
     "@eox/chart": "^0.4.0",
-    "@eox/drawtools": "^0.14.0",
-    "@eox/itemfilter": "^1.7.1",
-    "@eox/jsonform": "^0.15.4",
-    "@eox/layercontrol": "^0.29.0",
+    "@eox/drawtools": "^0.14.2",
+    "@eox/itemfilter": "^1.8.0",
+    "@eox/jsonform": "^0.16.1",
+    "@eox/layercontrol": "^0.29.1",
     "@eox/layout": "^0.3.0",
-    "@eox/map": "^1.19.4",
+    "@eox/map": "^1.20.0",
     "@eox/stacinfo": "^0.6.2",
     "@eox/timecontrol": "^0.12.3",
     "@mdi/js": "^7.4.47",
-    "@vitejs/plugin-vue": "^5.2.1",
+    "@vitejs/plugin-vue": "^5.2.3",
     "@vueuse/core": "^12.0.0",
     "animated-details": "gist:2912bb049fa906671807415eb0e87188",
-    "axios": "^1.7.9",
-    "axios-cache-interceptor": "^1.6.2",
+    "axios": "^1.8.4",
+    "axios-cache-interceptor": "^1.7.0",
     "color-legend-element": "^1.3.0",
     "commander": "^12.1.0",
-    "core-js": "^3.40.0",
+    "core-js": "^3.41.0",
     "loglevel": "^1.9.2",
     "mustache": "^4.2.0",
-    "pinia": "^2.3.1",
-    "sass": "^1.85.1",
+    "pinia": "^3.0.1",
+    "sass": "^1.86.0",
     "stac-js": "^0.0.9",
     "stac-ts": "^1.0.4",
     "v-calendar": "3.0.0",
-    "vega": "^5.32.0",
+    "vega": "^5.33.0",
     "vega-embed": "^6.29.0",
     "vega-lite": "^5.23.0",
-    "vite": "^6.2.0",
+    "vite": "^6.2.3",
     "vite-plugin-vuetify": "^2.1.0",
     "vue": "^3.5.0",
-    "vuetify": "^3.7.13",
+    "vuetify": "^3.7.18",
     "webfontloader": "^1.6.28"
   },
   "devDependencies": {
-    "@babel/types": "^7.26.9",
+    "@babel/types": "^7.27.0",
     "@eox/eslint-config": "^2.0.0",
     "@pinia/testing": "^0.1.7",
     "@types/json-schema": "^7.0.15",
     "@types/mustache": "^4.2.5",
-    "@types/node": "^22.13.5",
+    "@types/node": "^22.13.13",
     "@types/openlayers": "^4.6.23",
     "@types/webfontloader": "^1.6.38",
     "cypress": "^13.17.0",
-    "eslint": "^9.21.0",
-    "eslint-plugin-vue": "^9.32.0",
+    "eslint": "^9.23.0",
+    "eslint-plugin-vue": "^9.33.0",
     "pkg-pr-new": "^0.0.39",
-    "prettier": "^3.5.2",
-    "rollup": "^4.34.8",
+    "prettier": "^3.5.3",
+    "rollup": "^4.37.0",
     "terminate": "^2.8.0",
-    "tsc-alias": "^1.8.10",
-    "typedoc": "^0.27.9",
-    "typedoc-plugin-markdown": "^4.4.2",
-    "typedoc-plugin-vue": "^1.4.0",
+    "tsc-alias": "^1.8.11",
+    "typedoc": "^0.28.1",
+    "typedoc-plugin-markdown": "^4.6.0",
+    "typedoc-plugin-vue": "^1.5.0",
     "typedoc-vitepress-theme": "^1.1.2",
-    "typescript": "^5.7.3",
+    "typescript": "^5.8.2",
     "unplugin-fonts": "^1.3.1",
     "vitepress": "^1.6.3",
     "vitest": "^1.6.1",

package/widgets/EodashLayerControl.vue

@@ -28,12 +28,15 @@ import {
   eodashCollections,
   eodashCompareCollections,
   layerControlFormValue,
+  layerControlFormValueCompare,
 } from "@/utils/states";
 import { storeToRefs } from "pinia";
 import { useSTAcStore } from "@/store/stac";
 
 const props = defineProps({
   map: {
+    /** @type {import("vue").PropType<"first" | "second">} */
+    //@ts-expect-error todo
     type: String,
     default: "first",
   },
@@ -119,7 +122,11 @@ const debouncedHandleDateTime = (evt) => {
  * @param {Event & {detail:{layer:import("ol/layer").Layer;jsonformValue:Record<string,any>}}} evt
  */
 const onLayerConfigChange = (evt) => {
-  layerControlFormValue.value = evt.detail.jsonformValue;
+  if (props.map === "second") {
+    layerControlFormValueCompare.value = evt.detail.jsonformValue;
+  } else {
+    layerControlFormValue.value = evt.detail.jsonformValue;
+  }
 };
 
 const styleOverride = `

package/widgets/{EodashMap.vue → EodashMap/index.vue}

@@ -15,8 +15,8 @@
       .controls="controls"
     >
       <eox-map-tooltip
-        :style="tooltipStyles"
-        .propertyTransform="tooltipPropertyTransform"
+        :style="mainTooltipStyles"
+        .propertyTransform="tooltipPropertyTransform('main')"
       />
     </eox-map>
     <eox-map
@@ -26,11 +26,11 @@
       ref="compareMap"
       .layers="eoxMapCompareLayers"
     >
-    <eox-map-tooltip
-        :style="tooltipStyles"
-        .propertyTransform="tooltipPropertyTransform"
+      <eox-map-tooltip
+        :style="compareTooltipStyles"
+        .propertyTransform="tooltipPropertyTransform('compare')"
       />
-  </eox-map>
+    </eox-map>
   </eox-map-compare>
 </template>
 <script setup>
@@ -44,12 +44,13 @@ import {
   eodashCollections,
   eodashCompareCollections,
   layerControlFormValue,
+  layerControlFormValueCompare,
 } from "@/utils/states";
 import {
   useHandleMapMoveEnd,
   useInitMap,
   useUpdateTooltipProperties,
-} from "@/composables/EodashMap";
+} from "^/EodashMap/methods";
 import { inAndOut } from "ol/easing.js";
 import mustache from "mustache";
 
@@ -76,6 +77,8 @@ const props = defineProps({
 
 /** @type {import("vue").Ref<Exclude<import("@/types").EodashStyleJson["tooltip"], undefined>>} */
 const tooltipProperties = ref([]);
+/** @type {import("vue").Ref<Exclude<import("@/types").EodashStyleJson["tooltip"], undefined>>} */
+const compareTooltipProperties = ref([]);
 /** @type {import("@eox/map").EOxMap["controls"]} */
 const controls = {
   Attribution: {
@@ -147,6 +150,8 @@ onMounted(() => {
       eoxMap,
       false,
     );
+
+    useUpdateTooltipProperties(eodashCollections, compareTooltipProperties);
   }
 
   useInitMap(
@@ -163,35 +168,50 @@ onMounted(() => {
 
 useUpdateTooltipProperties(eodashCollections, tooltipProperties);
 
-const tooltipStyles = computed(() => ({
+const mainTooltipStyles = computed(() => ({
   visibility: tooltipProperties.value.length ? "visible" : "hidden",
 }));
+
+const compareTooltipStyles = computed(() => ({
+  visibility: compareTooltipProperties.value.length ? "visible" : "hidden",
+}));
 /**
- * @param {{key:string; value:string}} param
- * @returns {{key:string; value?:string} | undefined}
- */
-const tooltipPropertyTransform = (param) => {
-  /** @type {typeof tooltipProperties.value} */
-  const updatedProperties = JSON.parse(
-    mustache.render(JSON.stringify(tooltipProperties.value), {
-      ...(layerControlFormValue.value ?? {}),
-    }),
-  );
+ * @param {"main" | "compare"} map
+ **/
+const tooltipPropertyTransform = (map) => {
+  const tooltipProps =
+    map === "main" ? tooltipProperties : compareTooltipProperties;
+  const layerControlFormVal =
+    map == "main" ? layerControlFormValue : layerControlFormValueCompare;
+  /**
+   * @param {{key:string; value:string}} param
+   * @returns {{key:string; value?:string} | undefined}
+   */
+  return (param) => {
+    /** @type {typeof tooltipProps.value} */
+    const updatedProperties = JSON.parse(
+      mustache.render(JSON.stringify(tooltipProps.value), {
+        ...(layerControlFormVal.value ?? {}),
+      }),
+    );
 
-  const tooltipProp = updatedProperties?.find((prop) => prop.id === param.key);
-  if (!tooltipProp) {
-    return undefined;
-  }
-  if (typeof param.value === "object") {
-    param.value = JSON.stringify(param.value);
-  }
-  if (!isNaN(Number(param.value))) {
-    param.value = Number(param.value).toFixed(4).toString();
-  }
+    const tooltipProp = updatedProperties?.find(
+      (prop) => prop.id === param.key,
+    );
+    if (!tooltipProp) {
+      return undefined;
+    }
+    if (typeof param.value === "object") {
+      param.value = JSON.stringify(param.value);
+    }
+    if (!isNaN(Number(param.value))) {
+      param.value = Number(param.value).toFixed(4).toString();
+    }
 
-  return {
-    key: tooltipProp.title || tooltipProp.id,
-    value: param.value + " " + (tooltipProp.appendix || ""),
+    return {
+      key: tooltipProp.title || tooltipProp.id,
+      value: param.value + " " + (tooltipProp.appendix || ""),
+    };
   };
 };
 </script>

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

@@ -0,0 +1,151 @@
+import { EodashCollection } from "@/eodashSTAC/EodashCollection";
+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} [updatedTime]
+ */
+
+export const createLayersConfig = async (
+  selectedIndicator,
+  eodashCols,
+  updatedTime,
+) => {
+  log.debug(
+    "Creating layers config",
+    selectedIndicator,
+    eodashCols,
+    updatedTime,
+  );
+  const layersCollection = [];
+  const dataLayers = {
+    type: "Group",
+    properties: {
+      id: "AnalysisGroup",
+      title: "Data 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 geodbLayer = EodashCollection.getGeoDBLayer(eodashCols);
+  if (geodbLayer) {
+    dataLayers.layers.unshift(geodbLayer);
+  }
+  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;
+};