@eodash/eodash 5.7.1 → 5.8.0

package/core/client/eodashSTAC/helpers.js

@@ -1,6 +1,8 @@
 import { toAbsolute } from "stac-js/src/http.js";
 import axios from "@/plugins/axios";
 import log from "loglevel";
+import mustache from "mustache";
+import { updateVectorLayerStyle } from "@eox/layercontrol";
 import { getStyleVariablesState } from "./triggers.js";
 import { itemsCache, splitItemsCache } from "@/utils/states.js";
 
@@ -42,6 +44,26 @@ export function generateFeatures(links, extraProperties = {}, rel = "item") {
   return geojsonObject;
 }
 
+/**
+ * Fetches or extracts the raster form configuration for a STAC object.
+ * Supports direct JSON objects, data URIs, and URL strings.
+ *
+ * @param {string|object|undefined} rasterform - The rasterform property from the STAC object.
+ * @returns {Promise<import("@/types").EodashRasterJSONForm|undefined>}
+ */
+export async function fetchRasterForm(rasterform) {
+  if (!rasterform) {
+    return undefined;
+  }
+  if (typeof rasterform === "object") {
+    return /** @type {import("@/types").EodashRasterJSONForm} */ (rasterform);
+  }
+  if (typeof rasterform === "string") {
+    return await axios.get(rasterform).then((resp) => resp.data);
+  }
+  return undefined;
+}
+
 /**
  * Spearates and extracts layerConfig (jsonform schema & legend) from a style json
  *
@@ -98,6 +120,39 @@ export function extractLayerConfig(
   return { layerConfig, style };
 }
 
+/**
+ * Recursively extracts URL keys from a JSON Schema.
+ * Maps schema property names to their defined `url_key`.
+ * @param {Record<string, any> | null | undefined} schema
+ * @returns {Record<string, string>}
+ */
+export function extractUrlKeys(schema) {
+  /** @type {Record<string, string>} */
+  const keys = {};
+  if (!schema || typeof schema !== "object") return keys;
+
+  if (schema.properties) {
+    for (const [key, propDef] of Object.entries(schema.properties)) {
+      if (propDef && typeof propDef === "object") {
+        if (typeof propDef.url_key === "string") {
+          keys[key] = propDef.url_key;
+        }
+        Object.assign(keys, extractUrlKeys(propDef));
+      }
+    }
+  }
+
+  for (const combinator of ["oneOf", "allOf", "anyOf"]) {
+    if (Array.isArray(schema[combinator])) {
+      for (const sub of schema[combinator]) {
+        Object.assign(keys, extractUrlKeys(sub));
+      }
+    }
+  }
+
+  return keys;
+}
+
 /**
  *
  * @param {number[]} bbox
@@ -238,6 +293,7 @@ export const fetchAllStyles = async (stacObject) => {
     link.rel.includes("style"),
   );
   const fetchPromises = styleLinks.map(async (link) => {
+    /** @type {import("@/types").EodashStyleJson} */
     const styleJson = await axios.get(link.href).then((resp) => resp.data);
     log.debug("fetched styles JSON", JSON.parse(JSON.stringify(styleJson)));
     return styleJson;
@@ -560,20 +616,150 @@ export function assignProjID(item, linkOrAsset, id, layer) {
  *
  * @param {Record<string,any>[]} layers
  */
-export const removeUnneededProperties = (layers) => {
-  const cloned = structuredClone(layers);
-  cloned.forEach((layer) => {
-    const id = layer.properties.id;
-    const title = layer.properties.title;
-    layer.properties = { id, title };
-    if (layer["interactions"]) {
-      delete layer["interactions"];
+export const removeUnneededProperties = (layers, formValues = {}) => {
+  /**
+   * @param {Record<string,any>} layer
+   * @returns {Record<string,any>[]}
+   */
+  const processLayer = (layer) => {
+    // If the layer (or group) is explicitly marked as not visible, skip it and all children
+    if (layer.properties?.visible === false) {
+      return [];
     }
-    if (layer.type === "Group") {
-      layer.layers = removeUnneededProperties(layer.layers);
+
+    // If it's a Group, we just want its children
+    if (layer.type === "Group" && Array.isArray(layer.layers)) {
+      return layer.layers.flatMap(processLayer);
     }
-  });
-  return cloned;
+
+    // Break any Vue Proxies/OpenLayers getters by stringifying first
+    let clonedLayer;
+    try {
+      clonedLayer = JSON.parse(JSON.stringify(layer));
+    } catch (_e) {
+      clonedLayer = structuredClone(layer);
+    }
+
+    // Flatten formValues to handle nested properties (e.g., vminmax: { vmin, vmax })
+    /**
+     * @param {Record<string,any>} obj
+     * @returns {Record<string,any>}
+     */
+    const flattenFormValues = (obj) => {
+      /** @type {Record<string,any>} */
+      let result = {};
+      for (const key in obj) {
+        if (
+          obj[key] !== null &&
+          typeof obj[key] === "object" &&
+          !Array.isArray(obj[key])
+        ) {
+          Object.assign(result, flattenFormValues(obj[key]));
+        } else {
+          result[key] = obj[key];
+        }
+      }
+      return result;
+    };
+    const flatFormValues = flattenFormValues(formValues);
+
+    // Burn in style variables using Mustache if formValues are provided
+    if (Object.keys(flatFormValues).length > 0) {
+      // Stringify, render mustache, then parse back
+      try {
+        const renderedString = mustache.render(
+          JSON.stringify(clonedLayer),
+          flatFormValues,
+        );
+        clonedLayer = JSON.parse(renderedString);
+      } catch (e) {
+        log.warn(
+          "[eodash] Failed to apply mustache templating during export cleanup:",
+          e,
+        );
+      }
+    }
+
+    const {
+      id,
+      title,
+      mapboxStyle,
+      projection,
+      applyOptions,
+      layerConfig,
+      visible,
+    } = clonedLayer.properties || {};
+
+    // If style was not at root but in properties (layerConfig), move it to root early
+    if (!clonedLayer.style && layerConfig?.style) {
+      clonedLayer.style = layerConfig.style;
+    }
+
+    // Burn in OpenLayers ["var", "name"] variables using flatFormValues overriding style.variables
+    const styleVariables = {
+      ...(clonedLayer.style?.variables || {}),
+      ...flatFormValues,
+    };
+
+    if (clonedLayer.style && Object.keys(styleVariables).length > 0) {
+      clonedLayer.style = updateVectorLayerStyle({
+        ...clonedLayer.style,
+        variables: styleVariables,
+      });
+    }
+
+    clonedLayer.properties = {
+      id,
+      title,
+      ...(mapboxStyle && { mapboxStyle }),
+      ...(projection && { projection }),
+      ...(applyOptions && { applyOptions }),
+      ...(visible !== undefined && { visible }),
+    };
+
+    if (clonedLayer["interactions"]) {
+      delete clonedLayer["interactions"];
+    }
+
+    // Cleanup unnecessary properties
+    /**
+     * @param {any} obj
+     */
+    const cleanupProperties = (obj) => {
+      if (!obj || typeof obj !== "object") return;
+
+      for (const key in obj) {
+        if (obj[key] === null) {
+          delete obj[key];
+        } else if (Array.isArray(obj[key])) {
+          if (obj[key].length === 0) {
+            // Remove empty arrays like empty interactions
+            delete obj[key];
+          } else {
+            obj[key].forEach(cleanupProperties);
+          }
+        } else if (typeof obj[key] === "object") {
+          cleanupProperties(obj[key]);
+          if (Object.keys(obj[key]).length === 0) {
+            // we don't delete empty objects for now as it might break schema requirements
+          }
+        }
+      }
+    };
+    cleanupProperties(clonedLayer);
+
+    return [clonedLayer];
+  };
+
+  // ensure the top level array is also deeply un-proxied if needed
+  let rawLayers = layers;
+  try {
+    rawLayers = JSON.parse(JSON.stringify(layers));
+  } catch (_e) {
+    rawLayers = structuredClone(layers);
+  }
+
+  return rawLayers.flatMap(processLayer);
 };
 
 /**
@@ -764,6 +950,7 @@ export function getDatetimeProperty(linksOrItems) {
     return prop;
   }
 }
+
 /**
  *
  * @param {*} stacObject
@@ -1064,6 +1251,91 @@ export function updateGeoZarrBands(olLayer, jsonformValue) {
   return true;
 }
 
+/**
+ * Safely appends query parameters to a URL string, preserving templates like {z}/{x}/{y}
+ * @param {string} url
+ * @param {Record<string, string>} params
+ * @returns {string}
+ */
+function appendQueryParams(url, params) {
+  const [base, query] = url.split("?");
+  const searchParams = new URLSearchParams(query || "");
+
+  for (const [key, val] of Object.entries(params)) {
+    if (val !== undefined && val !== null && val !== "") {
+      searchParams.set(key, val);
+    } else {
+      searchParams.delete(key);
+    }
+  }
+
+  const newQuery = searchParams.toString();
+  return newQuery ? `${base}?${newQuery}` : base;
+}
+
+/**
+ * Checks whether a VectorTile layer's URL needs to be updated based on jsonform output.
+ * If the style's jsonform schema has properties with `url_key` defined, their values
+ * are injected as query parameters into the source URL.
+ *
+ * @param {import("ol/layer/Layer").default} olLayer - Layer from layerConfig:change event
+ * @param {Record<string, any>} jsonformValue - Current jsonform output
+ * @returns {boolean} true if the URL was updated
+ */
+export function updateLayerUrl(olLayer, jsonformValue) {
+  const jsonLayer = olLayer.get("_jsonDefinition");
+  if (!jsonLayer || jsonLayer.type !== "VectorTile") {
+    return false;
+  }
+
+  const schema = jsonLayer.properties?.layerConfig?.schema;
+  const urlKeys = extractUrlKeys(schema);
+
+  if (Object.keys(urlKeys).length === 0) {
+    return false;
+  }
+
+  let originalUrl = olLayer.get("originalUrl") || jsonLayer.source?.url;
+
+  if (!originalUrl || typeof originalUrl !== "string") {
+    return false;
+  }
+
+  if (!olLayer.get("originalUrl")) {
+    olLayer.set("originalUrl", originalUrl);
+  }
+
+  /** @type {Record<string, string>} */
+  const queryParamsToInject = {};
+  for (const [propName, urlKey] of Object.entries(urlKeys)) {
+    queryParamsToInject[urlKey] = jsonformValue[propName];
+  }
+
+  const newUrl = appendQueryParams(originalUrl, queryParamsToInject);
+
+  if (jsonLayer.source?.url) {
+    if (jsonLayer.source.url === newUrl) {
+      return false;
+    }
+    jsonLayer.source.url = newUrl;
+    if (olLayer.get("injectedUrl") === newUrl) {
+      return false;
+    }
+    const source = olLayer.getSource();
+    olLayer.set("injectedUrl", newUrl);
+    if (source && "setUrl" in source) {
+      /** @type {any} */ (source).setUrl(newUrl);
+      return true;
+    }
+    if (source && "setUrls" in source) {
+      /** @type {any} */ (source).setUrls([newUrl]);
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /**
  * Applies titiler upscaling to an XYZ tile URL based on the matched endpoint config.
  * - titiler v1: appends `@2x` to the `{y}` tile coordinate
@@ -1097,26 +1369,56 @@ export function applyTitilerUpscaling(url, upscalingEndpoints) {
 }
 
 /**
- * Picks the render presets for a collection, preferring the collection's own
- * STAC `renders` extension and falling back to client-provided config
- *
+ * Picks the render presets for a collection, preferring client-provided config
+ * (`options.renders[collectionId]`) and falling back to the collection's own STAC
+ * `renders` extension when no config entry exists.
  * @param {import("stac-ts").StacCollection | null | undefined} collection
  * @param {Record<string, Record<string, import("@/types").Render>> | undefined} [configRenders]
  * @returns {Record<string, import("@/types").Render> | undefined}
  */
 export function resolveRenders(collection, configRenders) {
-  if (collection?.renders) {
-    return /** @type {Record<string, import("@/types").Render>} */ (
-      collection.renders
-    );
+  const config = collection?.id ? configRenders?.[collection.id] : undefined;
+  if (config) return config;
+  return /** @type {Record<string, import("@/types").Render>|undefined} */ (
+    collection?.renders ?? undefined
+  );
+}
+
+/**
+ * TiTiler expects rescale as [min,max] pairs; chunks a flat numeric list
+ * into pairs (e.g. [0,0.4,0,0.1] -> [[0,0.4],[0,0.1]]). Nested input passes through.
+ * @param {number[]|number[][]|undefined} rescale - flat or nested rescale values
+ * @returns {number[][]|undefined} rescale as [min,max] pairs
+ */
+export function normalizeRescale(rescale) {
+  if (!rescale?.length || Array.isArray(rescale[0])) {
+    return /** @type {number[][]|undefined} */ (rescale);
   }
-  return collection?.id ? configRenders?.[collection.id] : undefined;
+  const pairs = [];
+  for (let i = 0; i < rescale.length; i += 2) {
+    pairs.push(/** @type {number[]} */ (rescale).slice(i, i + 2));
+  }
+  return pairs;
 }
 
 /**
- * Serializes an object into a TiTiler query string. Arrays join with commas;
- * nested arrays repeat the key (e.g. `rescale: [[0,1]]` -> `rescale=0,1`);
- * objects are JSON-encoded. Shared by the render-extension and mosaic paths.
+ * Drops NaN nodata values; NaN is already the implicit fill for float data,
+ * so forwarding `nodata=nan` to TiTiler is redundant.
+ * @param {string|number|undefined} nodata - nodata value from render/asset metadata
+ * @returns {string|number|undefined} nodata, or undefined when it is NaN
+ */
+export function normalizeNodata(nodata) {
+  if (typeof nodata === "number" && Number.isNaN(nodata)) return undefined;
+  if (typeof nodata === "string" && nodata.trim().toLowerCase() === "nan")
+    return undefined;
+  return nodata;
+}
+
+/**
+ * Serializes an object into a TiTiler query string. Arrays repeat the key per
+ * element (TiTiler list params, e.g. `assets=a&assets=b`); nested elements
+ * comma-join (`rescale: [[0,1],[0,2]]` -> `rescale=0,1&rescale=0,2`); objects
+ * are JSON-encoded. Shared by the render-extension and mosaic paths.
  * @param {Record<string,any>} obj
  * @returns {string}
  */
@@ -1132,23 +1434,12 @@ export function encodeURLObject(obj) {
 
     switch (valueType) {
       case "array": {
-        // Check if any element in the array is itself an array (multi-dimensional)
-        const hasNestedArrays = value.some((/** @type {any} */ item) =>
-          Array.isArray(item),
-        );
-
-        if (hasNestedArrays) {
-          // For multi-dimensional arrays, repeat the key with different values
-          for (const val of value) {
-            if (Array.isArray(val)) {
-              str += `${key}=${val.join(",")}&`;
-            } else {
-              str += `${key}=${val}&`;
-            }
+        for (const val of value) {
+          if (Array.isArray(val)) {
+            str += `${key}=${val.join(",")}&`;
+          } else {
+            str += `${key}=${encodeURIComponent(val)}&`;
           }
-        } else {
-          // For simple arrays, join with commas
-          str += `${key}=${value.join(",")}&`;
         }
         break;
       }

package/core/client/eodashSTAC/mosaic.js

@@ -25,6 +25,8 @@ import { useEodash, useOnLayersUpdate } from "@/composables";
 import {
   encodeURLObject,
   extractLayerTimeValues,
+  normalizeNodata,
+  normalizeRescale,
   resolveRenders,
 } from "./helpers";
 import { useSTAcStore } from "@/store/stac";
@@ -248,17 +250,21 @@ async function createMosaicLayers(mosaicEndpoint, params) {
   }
 
   const renderParamsStr = encodeURLObject({
-    assets: preset.assets,
+    // TiTiler treats assets and expression as mutually exclusive band selection
+    assets: preset.expression ? undefined : preset.assets,
     expression: preset.expression,
-    nodata: preset.nodata,
+    nodata: normalizeNodata(preset.nodata),
     resampling: preset.resampling,
     color_formula: preset.color_formula,
     colormap: preset.colormap,
     colormap_name: preset.colormap_name,
-    rescale: preset.rescale,
+    rescale: normalizeRescale(preset.rescale),
   });
 
-  const tileParams = new URLSearchParams({ tilesize: "512", ...params });
+  const tileParams = new URLSearchParams({
+    tilesize: `${preset.tilesize ?? "512"}`,
+    ...params,
+  });
   const tileJsonUrl = `${mosaicEndpoint}?${renderParamsStr}${tileParams.toString()}`;
 
   const tileJSON = await axios

package/core/client/store/stac.js

@@ -35,6 +35,12 @@ export const useSTAcStore = defineStore("stac", () => {
    */
   const supportedUpscalingEndpoints = ref([]);
 
+  /**
+   * Registry of colormap ranges
+   * @type {import("vue").Ref<Record<string, string[]> | null>}
+   */
+  const colormapRegistry = ref(null);
+
   /**
    * Links of the root STAC catalog
    *
@@ -94,6 +100,26 @@ export const useSTAcStore = defineStore("stac", () => {
     rasterEndpoint.value = endpoint.rasterEndpoint ?? null;
     supportedUpscalingEndpoints.value =
       endpoint.supportedUpscalingEndpoints ?? [];
+    if (endpoint.colormapRegistry) {
+      loadColormapRegistry(endpoint.colormapRegistry);
+    }
+  }
+
+  /**
+   * Loads the colormap registry from a URL or object
+   * @param {string | Record<string, string[]>} registry
+   */
+  async function loadColormapRegistry(registry) {
+    if (typeof registry === "object") {
+      colormapRegistry.value = registry;
+      return;
+    }
+    try {
+      const resp = await axios.get(registry);
+      colormapRegistry.value = resp.data;
+    } catch (err) {
+      log.error("Error loading colormap registry", err);
+    }
   }
 
   /**
@@ -167,6 +193,7 @@ export const useSTAcStore = defineStore("stac", () => {
     await axios
       .get(absoluteUrl.value)
       .then(async (resp) => {
+        resp.data["eodash:layerExclusive"] = true;
         await updateEodashCollections(
           eodashCollections,
           resp.data,
@@ -279,5 +306,7 @@ export const useSTAcStore = defineStore("stac", () => {
     selectedItem,
     selectedCompareItem,
     supportedUpscalingEndpoints,
+    colormapRegistry,
+    loadColormapRegistry,
   };
 });

package/core/client/types.ts

@@ -339,6 +339,7 @@ export type StacEndpoint =
       supportedUpscalingEndpoints?: Array<
         string | { url: string; titilerVersion?: 1 | 2 }
       >;
+      colormapRegistry?: string | Record<string, string[]>;
     };
 
 /** @group Eodash */
@@ -647,6 +648,10 @@ export interface Render {
   expression?: string;
   /** Zoom levels range applicable for the visualization */
   minmax_zoom?: number[];
+  /** Band indexes to apply the rendering to. */
+  bidx?: number[];
+  /** Tile size to request from the tile server. */
+  tilesize?: number;
 }
 /** @ignore */
 export interface TitilerSTACParameters {

package/dist/client/{DashboardLayout-ePbdvUTE.js → DashboardLayout-DEs4f_Vy.js}

@@ -1,7 +1,7 @@
 import { openBlock, createBlock, withCtx, createElementVNode, unref, createElementBlock, normalizeStyle, Suspense, resolveDynamicComponent, mergeProps, createCommentVNode, Fragment, renderList, Transition } from 'vue';
 import '@eox/layout';
-import { _ as _export_sfc, u as useDefineTemplate } from './asWebComponent-BlFN2lkB.js';
-import { V as VMain } from './VMain-7yqk_qC3.js';
+import { _ as _export_sfc, u as useDefineTemplate } from './asWebComponent-IZanwL-A.js';
+import { V as VMain } from './VMain-DvMmOL4f.js';
 
 const _style_0 = ".panel[data-v-f357e3a7]{position:relative;overflow:auto;z-index:1;pointer-events:none}.pointer[data-v-f357e3a7]{pointer-events:all}.bg-panel[data-v-f357e3a7]{z-index:0;border-radius:0!important}.fade-enter-active[data-v-f357e3a7],.fade-leave-active[data-v-f357e3a7]{transition:opacity .25s ease}.fade-enter-from[data-v-f357e3a7],.fade-leave-to[data-v-f357e3a7]{opacity:0}.bg-surface[data-v-f357e3a7],.bg-primary[data-v-f357e3a7]{backdrop-filter:blur(10px)!important;border-radius:8px;border:none;box-shadow:0 0 1px #18274b38,0 6px 12px -6px #18274b1f,0 8px 24px -4px #18274b14;max-height:100%;overflow:auto;scrollbar-color:rgba(var(--v-theme-on-surface),.2) transparent;scrollbar-width:thin}.bg-surface[data-v-f357e3a7]{background-color:rgba(var(--v-theme-surface),var(--v-surface-opacity, .8))!important}.bg-primary[data-v-f357e3a7]{background-color:rgba(var(--v-theme-primary),var(--v-primary-opacity, .8))!important}";
 

package/dist/client/{DynamicWebComponent-g5SdRbjY.js → DynamicWebComponent-PvnV88BA.js}

@@ -1,5 +1,5 @@
 import { withAsyncContext, ref, onMounted, onUnmounted, openBlock, createElementBlock, createBlock, resolveDynamicComponent, mergeProps } from 'vue';
-import { H as useSTAcStore } from './asWebComponent-BlFN2lkB.js';
+import { H as useSTAcStore } from './asWebComponent-IZanwL-A.js';
 
 const _hoisted_1 = { class: "d-flex flex-column fill-height overflow-auto" };