@eodash/eodash 5.0.0-rc.3 → 5.1.0

package/core/client/eodashSTAC/helpers.js

@@ -6,14 +6,15 @@ import { getStyleVariablesState } from "./triggers.js";
 /**
  *  @param {import("stac-ts").StacLink[]} [links]
  *  @param {Record<string,any>} [extraProperties]
+ * @param {string} [rel = "item"]
  **/
-export function generateFeatures(links, extraProperties = {}) {
+export function generateFeatures(links, extraProperties = {}, rel = "item") {
   /**
    * @type {import("geojson").Feature[]}
    */
   const features = [];
   links?.forEach((element) => {
-    if (element.rel === "item" && "latlng" in element) {
+    if (element.rel === rel && "latlng" in element) {
       const [lat, lon] = /** @type {string} */ (element.latlng)
         .split(",")
         .map((it) => Number(it));
@@ -177,9 +178,9 @@ export const extractLayerDatetime = (links, currentStep) => {
   }
 
   // check if links has a datetime value
-  // TODO: consider datetime ranges
-  const hasDatetime = links.some((l) => typeof l.datetime === "string");
-  if (!hasDatetime) {
+  const dateProperty = getDatetimeProperty(links);
+
+  if (!dateProperty) {
     return undefined;
   }
 
@@ -187,11 +188,10 @@ export const extractLayerDatetime = (links, currentStep) => {
   const controlValues = [];
   try {
     currentStep = new Date(currentStep).toISOString();
-
     links.reduce((vals, link) => {
-      if (link.datetime && link.rel === "item") {
+      if (link[dateProperty] && link.rel === "item") {
         vals.push(
-          new Date(/** @type {string} */ (link.datetime)).toISOString(),
+          new Date(/** @type {string} */ (link[dateProperty])).toISOString(),
         );
       }
       return vals;
@@ -207,7 +207,12 @@ export const extractLayerDatetime = (links, currentStep) => {
 
   // item datetime is not included in the item links datetime
   if (!controlValues.includes(currentStep)) {
-    return undefined;
+    const currentStepTime = new Date(currentStep).getTime();
+    currentStep = controlValues.reduce((a, b) => {
+      const aDiff = Math.abs(new Date(a).getTime() - currentStepTime);
+      const bDiff = Math.abs(new Date(b).getTime() - currentStepTime);
+      return bDiff < aDiff ? b : a;
+    });
   }
 
   return {
@@ -223,8 +228,8 @@ export const extractLayerDatetime = (links, currentStep) => {
 /**
  * Find JSON layer by ID
  *  @param {string} layer
- *  @param {Record<string, any>[]} layers
- *  @returns {Record<string,any> | undefined}
+ *  @param {import("@eox/map").EoxLayer[]} layers
+ *  @returns {import("@eox/map").EoxLayer | undefined}
  **/
 export const findLayer = (layers, layer) => {
   for (const lyr of layers) {
@@ -235,7 +240,7 @@ export const findLayer = (layers, layer) => {
       }
       return found;
     }
-    if (lyr.properties.id === layer) {
+    if (lyr.properties?.id === layer) {
       return lyr;
     }
   }
@@ -243,14 +248,14 @@ export const findLayer = (layers, layer) => {
 
 /**
  * Removes the layer with the id provided and injects an array of layers in its position
- * @param {Record<string,any>[]} currentLayers
+ * @param {import("@eox/map").EoxLayer[]} currentLayers
  * @param {string} oldLayer - id of the layer to be replaced
- * @param {Record<string,any>[]} newLayers - array of layers to replace the old layer
- * @returns {Record<string,any>[] | undefined}
+ *  @param {import("@eox/map").EoxLayer[]} newLayers - array of layers to replace the old layer
+ * @returns {import("@eox/map").EoxLayer[]}
  */
 export const replaceLayer = (currentLayers, oldLayer, newLayers) => {
   const oldLayerIdx = currentLayers.findIndex(
-    (l) => l.properties.id === oldLayer,
+    (l) => l.properties?.id === oldLayer,
   );
 
   if (oldLayerIdx !== -1) {
@@ -258,10 +263,9 @@ export const replaceLayer = (currentLayers, oldLayer, newLayers) => {
       "Replacing layer",
       oldLayer,
       "with",
-      newLayers.map((l) => l.properties.id),
+      newLayers.map((l) => l.properties?.id),
     );
     currentLayers.splice(oldLayerIdx, 1, ...newLayers);
-    return currentLayers;
   }
 
   for (const l of currentLayers) {
@@ -269,10 +273,10 @@ export const replaceLayer = (currentLayers, oldLayer, newLayers) => {
       const updatedGroupLyrs = replaceLayer(l.layers, oldLayer, newLayers);
       if (updatedGroupLyrs?.length) {
         l.layers = updatedGroupLyrs;
-        return currentLayers;
       }
     }
   }
+  return currentLayers;
 };
 
 /**
@@ -281,18 +285,21 @@ export const replaceLayer = (currentLayers, oldLayer, newLayers) => {
  * @param {import('../eodashSTAC/EodashCollection.js').EodashCollection[]} indicators
  * @param {import('ol/layer').Layer} layer
  */
-export const getColFromLayer = async (indicators, layer) => {
+export const getColFromLayer = (indicators, layer) => {
   // init cols
-  const collections = await Promise.all(
-    indicators.map((ind) => ind.fetchCollection()),
-  );
+  const collections = indicators.map((ind) => ind.collectionStac);
   const [collectionId, itemId, ..._other] = layer.get("id").split(";:;");
 
   const chosen = collections.find((col) => {
     const isInd =
-      col.id === collectionId &&
-      col.links?.some(
-        (link) => link.rel === "item" && link.href.includes(itemId),
+      col?.id === collectionId &&
+      col?.links?.some(
+        (link) =>
+          link.rel === "item" &&
+          (link.href.includes(itemId) ||
+            link.id === itemId ||
+            //@ts-expect-error attaching the item in link when parsing .parquet items, see @/eodashSTAC/parquet.js
+            (link["item"] && link["item"].id === itemId)),
       );
     return isInd;
   });
@@ -306,7 +313,7 @@ export const getColFromLayer = async (indicators, layer) => {
  * @param {string} collectionId
  * @param {string} itemId
  * @param {import('stac-ts').StacLink} link
- * @param {string} projectionCode
+ * @param {string | import("ol/proj").ProjectionLike} projectionCode
  *
  */
 export const createLayerID = (collectionId, itemId, link, projectionCode) => {
@@ -419,6 +426,87 @@ export async function mergeGeojsons(geojsonUrls) {
   );
 }
 
+/**
+ *
+ * @param {import("stac-ts").StacItem[]} items
+ */
+export function generateLinksFromItems(items) {
+  /**
+   * @param {string|Date} datetime
+   * @returns
+   */
+  function formateDatetime(datetime) {
+    if (datetime instanceof Date) {
+      return datetime.toISOString();
+    }
+    if (typeof datetime === "string") {
+      const date = new Date(datetime);
+      return date.toISOString();
+    }
+    return datetime;
+  }
+
+  return items.map((item) => {
+    const itemBlob = new Blob([JSON.stringify(item)], {
+      type: "application/geo+json",
+    });
+    // urls are revoked when updating the collection. see updateEodashCollections in "../utils/index.js"
+    const itemUrl = URL.createObjectURL(itemBlob);
+    return {
+      id: item.id,
+      rel: "item",
+      type: "application/geo+json",
+      title: item.id,
+      href: itemUrl,
+      ...(item.properties.datetime && {
+        datetime: formateDatetime(item.properties.datetime),
+      }),
+      ...(item.properties.start_datetime && {
+        start_datetime: formateDatetime(item.properties.start_datetime),
+      }),
+      ...(item.properties.end_datetime && {
+        end_datetime: formateDatetime(item.properties.end_datetime),
+      }),
+      //@ts-expect-error projection extension
+      ...(item.properties?.["proj:epsg"] && {
+        "proj:epsg": /** @type {number} **/ (item.properties["proj:epsg"]),
+      }),
+      //@ts-expect-error eodash projection
+      ...(item.properties?.["eodash:proj4_def"] && {
+        "eodash:proj4_def": item.properties["eodash:proj4_def"],
+      }),
+
+      ...(item.geometry?.type == "Point" &&
+        item.geometry?.coordinates.length && {
+          latlng: item.geometry.coordinates.reverse().join(","),
+        }),
+      ...(Object.values(item.assets ?? {}).some(
+        (asset) =>
+          asset.href.startsWith("s3://veda-data-store") &&
+          asset.type === "image/tiff; application=geotiff",
+      ) && {
+        cog_href: Object.values(item.assets ?? {}).find((asset) =>
+          asset.href.startsWith("s3://veda-data-store"),
+        )?.href,
+      }),
+    };
+  });
+}
+
+/**
+ * @param {import("../eodashSTAC/EodashCollection.js").EodashCollection} collection
+ */
+export function revokeCollectionBlobUrls(collection) {
+  collection.collectionStac?.links.forEach((link) => {
+    if (!(link.rel === "item" && link.type === "application/geo+json")) {
+      return;
+    }
+    if (link.href.startsWith("blob:")) {
+      URL.revokeObjectURL(link.href);
+    }
+  });
+}
+
 /**
  * adds tooltip to the layer if the style has tooltip property
  * @param {Record<string,any>} layer
@@ -441,3 +529,24 @@ export const addTooltipInteraction = (layer, style) => {
     ];
   }
 };
+
+/**
+ *
+ * @param {import("stac-ts").StacLink[]} [links]
+ */
+export function getDatetimeProperty(links) {
+  if (!links?.length) {
+    return undefined;
+  }
+  // TODO: consider other properties for datetime ranges
+  const datetimeProperties = ["datetime", "start_datetime", "end_datetime"];
+  for (const prop of datetimeProperties) {
+    const propExists = links.some(
+      (l) => l[prop] && typeof l[prop] === "string",
+    );
+    if (!propExists) {
+      continue;
+    }
+    return prop;
+  }
+}

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
+  );
+};