@eodash/eodash 5.0.0 → 5.2.0

package/core/client/eodashSTAC/parquet.js

@@ -0,0 +1,145 @@
+import { parquetRead } from "hyparquet";
+import WKB from "ol/format/WKB.js";
+import GeoJSON from "ol/format/GeoJSON";
+import log from "loglevel";
+
+/**
+ * @param {string} url
+ */
+export const readParquetItems = async (url) => {
+  /** @type {import("stac-ts").StacItem[]} */
+  let items = [];
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Accept: "application/octet-stream",
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
+  }
+  const contentType = response.headers.get("Content-Type") || "";
+  if (
+    !contentType.includes("application") &&
+    !contentType.includes("octet-stream") &&
+    !url.endsWith(".parquet")
+  ) {
+    console.warn(
+      "Response may not be a Parquet file. Content-Type:",
+      contentType,
+    );
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  if (arrayBuffer.byteLength < 8) {
+    throw new Error(
+      "Downloaded buffer is too small to be a valid Parquet file.",
+    );
+  }
+  await parquetRead({
+    file: arrayBuffer,
+    rowFormat: "object",
+    // set utf8 to false to avoid parsing wkb to string
+    utf8: false,
+    /*** @param {import("stac-ts").StacItem[]} data */
+    //@ts-expect-error rows are expected be array of arrays in hyparquet
+    onComplete: (data) => {
+      items.push(...(adjustParquetItems(data) ?? []));
+    },
+  });
+  log.debug("Adjusted Parquet items", items);
+  return items;
+};
+
+/**
+ *
+ * @param {import("stac-ts").StacItem[]} items
+ */
+export const adjustParquetItems = (items) => {
+  return items.map((item) => {
+    item = moveItemProperties(item);
+    item = adjustItemsBigInts(item);
+
+    return /** @type {import("stac-ts").StacItem} */ ({
+      ...item,
+      //@ts-expect-error geometry wkb conversion by stac-geoparquet
+      geometry: wkbToGeometry(item.geometry),
+
+      assets: ((assets) => {
+        for (const [key, value] of Object.entries(assets)) {
+          if (!value || !value.href) {
+            delete assets[key];
+          }
+        }
+        return assets;
+      })(item.assets),
+
+      bbox: ((bbox) => {
+        //@ts-expect-error bbox conversion by stac-geoparquet
+        const { xmax, xmin, ymax, ymin } = bbox;
+        return [xmin, ymin, xmax, ymax].map((v) => parseFloat(v));
+      })(item.bbox),
+    });
+  });
+};
+/**
+ *  @param {Uint8Array} wkb - Well Known Binary
+ */
+function wkbToGeometry(wkb) {
+  const geoJsonFormatter = new GeoJSON();
+  const wkbReader = new WKB();
+  const olGeometry = wkbReader.readGeometry(wkb);
+  return geoJsonFormatter.writeGeometryObject(olGeometry);
+}
+
+/**
+ *
+ * @param {import("stac-ts").StacItem} item
+ */
+function moveItemProperties(item) {
+  const stacProperties = [
+    "assets",
+    "links",
+    "bbox",
+    "geometry",
+    "stac_version",
+    "stac_extensions",
+    "type",
+    "id",
+    "collection",
+    "properties",
+  ];
+  for (const key in item) {
+    if (!stacProperties.includes(key)) {
+      if (!item.properties) {
+        item.properties = {};
+      }
+      item.properties[key] = item[key];
+      delete item[key];
+    }
+  }
+  return item;
+}
+
+/**
+ *
+ * @param {import("stac-ts").StacItem} item
+ */
+function adjustItemsBigInts(item) {
+  /** @param {*} obj */
+  const adjustBigInt = (obj) => {
+    for (const key in obj ?? {}) {
+      if (typeof obj[key] === "bigint") {
+        obj[key] = parseFloat(obj[key].toString());
+      } else if (typeof obj[key] === "object" && obj[key] !== null) {
+        adjustBigInt(obj[key]);
+      }
+    }
+  };
+  adjustBigInt(item.links);
+  adjustBigInt(item.properties);
+  adjustBigInt(item.assets);
+  adjustBigInt(item.bbox);
+  adjustBigInt(item.geometry);
+  return item;
+}

package/core/client/eodashSTAC/triggers.js

@@ -52,9 +52,12 @@ export function getStyleVariablesState(collectionId, variables) {
     return variables;
   }
 
-  const analysisGroup = mapElement.layers.find(
-    (layer) => layer.properties?.id === "AnalysisGroup",
-  );
+  const analysisGroup =
+    /** @type {import("@eox/map/src/layers").EOxLayerTypeGroup | undefined} */ (
+      mapElement.layers.find(
+        (layer) => layer.properties?.id === "AnalysisGroup",
+      )
+    );
   if (!analysisGroup) {
     return variables;
   }

package/core/client/plugins/index.js

@@ -1,10 +1,10 @@
 import vuetify from "./vuetify";
 import { createPinia } from "pinia";
-import eodash from "@/eodash";
 import VCalendar from "v-calendar";
-import { eodashKey } from "@/utils/keys";
 import store from "../store";
 import log from "loglevel";
+import { eodashKey } from "@/utils/keys";
+import { reactive } from "vue";
 
 export const pinia = createPinia();
 
@@ -17,5 +17,6 @@ export function registerPlugins(app) {
     .use(pinia)
     // Use plugin with optional defaults
     .use(VCalendar, {})
-    .provide(eodashKey, eodash);
+    //@ts-expect-error reactive placeholder for eodash
+    .provide(eodashKey, reactive({}));
 }

package/core/client/plugins/vuetify.js

@@ -6,11 +6,14 @@
 
 // Styles
 import "vuetify/styles";
+import "@eox/ui/vuetify/style.css";
+import { eox } from "@eox/ui/vuetify/blueprint.js";
 
 import { createVuetify } from "vuetify";
 import { mdiChevronLeft, mdiChevronRight, mdiMenuDown, mdiPlus } from "@mdi/js";
 
 const vuetify = createVuetify({
+  blueprint: eox,
   icons: {
     aliases: {
       // mapping v-date-picker and v-tabs default icons to `@mdi/js`

package/core/client/store/actions.js

@@ -3,21 +3,24 @@ import {
   mapCompareEl,
   registeredProjections,
   activeTemplate,
+  poi,
+  comparePoi,
 } from "@/store/states";
 import { getProjectionCode } from "@/eodashSTAC/helpers";
 import log from "loglevel";
 
 /**
  * Returns the current layers of {@link mapEl}
- * @returns {Record<string,any>[]}
+ * @returns {import("@eox/map").EoxLayer[]}
  */
-export const getLayers = () => mapEl.value?.layers.toReversed();
+export const getLayers = () => mapEl.value?.layers.toReversed() ?? [];
 
 /**
  * Returns the current layers of {@link mapCompareEl}
- * @returns {Record<string,any>[]}
+ * * @returns {import("@eox/map").EoxLayer[]}
  */
-export const getCompareLayers = () => mapCompareEl.value?.layers.toReversed();
+export const getCompareLayers = () =>
+  mapCompareEl.value?.layers.toReversed() ?? [];
 
 /**
  * Register EPSG projection in `eox-map`
@@ -77,3 +80,17 @@ export const setActiveTemplate = (template) => {
   activeTemplate.value = template;
   log.debug("Setting active template to", template);
 };
+
+/**
+ * Check whether the collection needs an EodashProcess Widget
+ * @param {import("stac-ts").StacCollection | null | undefined} collection
+ * @param {boolean} [compare=false] - Whether to check for compare collection
+ * @returns
+ */
+export const includesProcess = (collection, compare = false) => {
+  const isPoiAlive = compare ? !!comparePoi.value : !!poi.value;
+
+  return (
+    collection?.links?.some((link) => link.rel === "service") || isPoiAlive
+  );
+};

package/core/client/store/stac.js

@@ -1,20 +1,28 @@
 import { defineStore } from "pinia";
-import { inject, ref } from "vue";
+import { ref } from "vue";
 import axios from "@/plugins/axios";
-import { useAbsoluteUrl, useCompareAbsoluteUrl } from "@/composables/index";
-import { eodashKey } from "@/utils/keys";
-import { indicator } from "@/store/states";
-import { extractCollectionUrls } from "@/eodashSTAC/helpers";
+import {
+  useAbsoluteUrl,
+  useCompareAbsoluteUrl,
+  useGetSubCodeId,
+} from "@/composables/index";
+import { compareIndicator, comparePoi, indicator, poi } from "@/store/states";
 import {
   eodashCollections,
   eodashCompareCollections,
   collectionsPalette,
-  switchToCompare,
 } from "@/utils/states";
-import { EodashCollection } from "@/eodashSTAC/EodashCollection";
 import log from "loglevel";
+import { toAbsolute } from "stac-js/src/http.js";
+import { updateEodashCollections } from "@/utils";
 
 export const useSTAcStore = defineStore("stac", () => {
+  /**
+   * STAC catalog endpoint URL
+   * @type {import("vue").Ref<import("@/types").StacEndpoint | null>}
+   */
+  const stacEndpoint = ref(null);
+
   /**
    * Links of the root STAC catalog
    *
@@ -26,9 +34,7 @@ export const useSTAcStore = defineStore("stac", () => {
    * Selected STAC object.
    *
    * @type {import("vue").Ref<
-   *   | import("stac-ts").StacCatalog
    *   | import("stac-ts").StacCollection
-   *   | import("stac-ts").StacItem
    *   | null
    * >}
    */
@@ -38,15 +44,19 @@ export const useSTAcStore = defineStore("stac", () => {
    * Selected STAC object.
    *
    * @type {import("vue").Ref<
-   *   | import("stac-ts").StacCatalog
    *   | import("stac-ts").StacCollection
-   *   | import("stac-ts").StacItem
    *   | null
    * >}
    */
   const selectedCompareStac = ref(null);
 
-  const eodash = /** @type {import("@/types").Eodash} */ (inject(eodashKey));
+  /**
+   * Initializes the store by assigning the STAC endpoint.
+   * @param {import("@/types").StacEndpoint} endpoint
+   */
+  function init(endpoint) {
+    stacEndpoint.value = endpoint;
+  }
 
   /**
    * Fetches root stac catalog and assign it to `stac`
@@ -56,7 +66,19 @@ export const useSTAcStore = defineStore("stac", () => {
    * @returns {Promise<void>}
    * @see {@link stac}
    */
-  async function loadSTAC(url = eodash.stacEndpoint) {
+  async function loadSTAC(url) {
+    if (!url) {
+      if (!stacEndpoint.value) {
+        throw new Error("STAC endpoint is not defined in eodash configuration");
+      }
+      url = stacEndpoint.value;
+    }
+
+    if (!url) {
+      stac.value = null;
+      return;
+    }
+
     log.debug("Loading STAC endpoint", url);
     await axios
       .get(url)
@@ -81,44 +103,40 @@ export const useSTAcStore = defineStore("stac", () => {
    * Fetches selected stac object and assign it to `selectedStac`
    *
    * @param {string} relativePath - Stac link href
+   * @param {boolean} [isPoi=false] - If true, the STAC is loaded for a point of interest
    * @returns {Promise<void>}
    * @see {@link selectedStac}
    */
-  async function loadSelectedSTAC(relativePath = "") {
-    const absoluteUrl = useAbsoluteUrl(relativePath);
+  async function loadSelectedSTAC(relativePath = "", isPoi = false) {
+    if (!stacEndpoint.value) {
+      return Promise.reject(new Error("STAC endpoint is not defined"));
+    }
+    const absoluteUrl = useAbsoluteUrl(relativePath, stacEndpoint.value);
+    if (isPoi) {
+      // construct absolute URL of a poi
+      absoluteUrl.value = constructPoiUrl(relativePath, indicator.value);
+    }
 
     await axios
       .get(absoluteUrl.value)
       .then(async (resp) => {
-        // init eodash collections
-        const collectionUrls = extractCollectionUrls(
+        await updateEodashCollections(
+          eodashCollections,
           resp.data,
           absoluteUrl.value,
+          collectionsPalette,
         );
-
-        await Promise.all(
-          collectionUrls.map((cu, idx) => {
-            const ec = new EodashCollection(cu);
-            ec.fetchCollection();
-            ec.color = collectionsPalette[idx % collectionsPalette.length];
-            return ec;
-          }),
-        ).then((collections) => {
-          // empty array from old collections
-          eodashCollections.splice(0, eodashCollections.length);
-          // update eodashCollections
-          eodashCollections.push(...collections);
-
-          selectedStac.value = resp.data;
-          indicator.value = selectedStac.value?.id ?? "";
-          switchToCompare.value = true;
-        });
+        selectedStac.value = resp.data;
+        // set indicator and poi
+        indicator.value = isPoi
+          ? indicator.value
+          : useGetSubCodeId(selectedStac.value);
+        poi.value = isPoi ? (selectedStac.value?.id ?? "") : "";
       })
       .catch((err) => {
         throw new Error("error loading the selected STAC", err);
       });
   }
-
   /**
    * Fetches selected stac object and assign it to `selectedCompareStac`
    *
@@ -126,32 +144,31 @@ export const useSTAcStore = defineStore("stac", () => {
    * @returns {Promise<void>}
    * @see {@link selectedCompareStac}
    */
-  async function loadSelectedCompareSTAC(relativePath = "") {
-    const absoluteUrl = useCompareAbsoluteUrl(relativePath);
+  async function loadSelectedCompareSTAC(relativePath = "", isPOI = false) {
+    if (!stacEndpoint.value) {
+      return Promise.reject(
+        new Error("STAC endpoint is not defined in eodash configuration"),
+      );
+    }
+    const absoluteUrl = useCompareAbsoluteUrl(relativePath, stacEndpoint.value);
+    if (isPOI) {
+      // construct absolute URL of a poi
+      absoluteUrl.value = constructPoiUrl(relativePath, compareIndicator.value);
+    }
     await axios
       .get(absoluteUrl.value)
       .then(async (resp) => {
-        // init eodash collections
-        const collectionUrls = await extractCollectionUrls(
+        await updateEodashCollections(
+          eodashCompareCollections,
           resp.data,
           absoluteUrl.value,
+          [...collectionsPalette].reverse(),
         );
-
-        await Promise.all(
-          collectionUrls.map((cu) => {
-            const ec = new EodashCollection(cu);
-            ec.fetchCollection();
-            return ec;
-          }),
-        ).then((collections) => {
-          // empty array from old collections
-          eodashCompareCollections.splice(0, eodashCompareCollections.length);
-          // update eodashCompareCollections
-          eodashCompareCollections.push(...collections);
-
-          selectedCompareStac.value = resp.data;
-          switchToCompare.value = false;
-        });
+        selectedCompareStac.value = resp.data;
+        compareIndicator.value = isPOI
+          ? compareIndicator.value
+          : useGetSubCodeId(selectedCompareStac.value);
+        comparePoi.value = isPOI ? (selectedCompareStac.value?.id ?? "") : "";
       })
       .catch((err) => {
         throw new Error("error loading the selected comparison STAC", err);
@@ -163,11 +180,31 @@ export const useSTAcStore = defineStore("stac", () => {
    *
    */
   async function resetSelectedCompareSTAC() {
+    eodashCompareCollections.splice(0, eodashCompareCollections.length);
     selectedCompareStac.value = null;
   }
 
+  /**
+   * Construct absolute URL of a point of interest (POI)
+   *
+   * @param {string} relativePath - The relative path to the POI
+   * @param {string} indicatorStr - selected indicator id or subcode
+   */
+  function constructPoiUrl(relativePath, indicatorStr) {
+    if (!stacEndpoint.value) {
+      throw new Error("STAC endpoint is not defined in eodash configuration");
+    }
+    // construct absolute URL of a poi
+    const indicatorUrl =
+      stac.value?.find((link) => useGetSubCodeId(link) === indicatorStr)
+        ?.href ?? "";
+    const absoluteIndicatorUrl = toAbsolute(indicatorUrl, stacEndpoint.value);
+    return toAbsolute(relativePath, absoluteIndicatorUrl);
+  }
+
   return {
     stac,
+    init,
     loadSTAC,
     loadSelectedSTAC,
     loadSelectedCompareSTAC,

package/core/client/store/states.js

@@ -2,7 +2,7 @@
 import log from "loglevel";
 log.setLevel(log.levels.WARN, true);
 
-import { ref } from "vue";
+import { ref, shallowRef } from "vue";
 
 /** Currently selected STAC endpoint */
 export const currentUrl = ref("");
@@ -15,6 +15,8 @@ export const datetime = ref(new Date().toISOString());
 
 /** Currently selected indicator */
 export const indicator = ref("");
+/** Currently selected compare indicator */
+export const compareIndicator = ref("");
 
 /**
  * Current map position
@@ -28,10 +30,18 @@ export const registeredProjections = ["EPSG:4326", "EPSG:3857"];
 /** available projection to be rendered by `EodashMap` */
 export const availableMapProjection = ref("EPSG:3857");
 
-/** @type {import("vue").Ref<HTMLElement & Record<string,any> | null>} */
-export const mapEl = ref(null);
+/** @type {import("vue").Ref<import("@eox/map").EOxMap | null>} */
+export const mapEl = shallowRef(null);
 
-/** @type {import("vue").Ref<HTMLElement & Record<string,any> | null>} */
-export const mapCompareEl = ref(null);
+/** @type {import("vue").Ref<import("@eox/map").EOxMap | null>} */
+export const mapCompareEl = shallowRef(null);
 
 export const activeTemplate = ref("");
+/**
+ * Selected point of interest, used for location collections
+ */
+export const poi = ref("");
+/**
+ * Selected point of interest for comparison, used for location collections
+ */
+export const comparePoi = ref("");