@eodash/eodash 5.7.0 → 5.7.1

package/dist/client/templates.js

@@ -1,16 +1,12 @@
 import { mdiViewDashboardVariant, mdiViewDashboard } from '@mdi/js';
-import { O as includesProcess, P as shouldShowChartWidget } from './helpers-DjZVl_WF.js';
+import { Z as includesProcess, _ as shouldShowChartWidget } from './helpers-CBqIUSXJ.js';
 
 /**
  * Special values that tell deepmerge to perform a certain action.
  */
 const actions = {
-    defaultMerge: Symbol("deepmerge-ts: default merge")};
-/**
- * Special values that tell deepmergeInto to perform a certain action.
- */
-const actionsInto = {
-    defaultMerge: actions.defaultMerge,
+    defaultMerge: Symbol("deepmerge-ts: default merge"),
+    skip: Symbol("deepmerge-ts: skip"),
 };
 
 /**
@@ -156,12 +152,12 @@ function isRecord(value) {
 }
 
 /**
- * The default strategy to merge records into a target record.
+ * The default strategy to merge records.
  *
- * @param mut_target - The result will be mutated into this record
- * @param values - The records (including the target's value if there is one).
+ * @param values - The records.
  */
-function mergeRecordsInto$1(mut_target, values, utils, meta) {
+function mergeRecords$1(values, utils, meta) {
+    const result = {};
     for (const key of getKeys(values)) {
         const propValues = [];
         for (const value of values) {
@@ -176,202 +172,209 @@ function mergeRecordsInto$1(mut_target, values, utils, meta) {
             key,
             parents: values,
         });
-        const propertyTarget = { value: propValues[0] };
-        mergeUnknownsInto(propertyTarget, propValues, utils, updatedMeta);
+        const propertyResult = mergeUnknowns(propValues, utils, updatedMeta);
+        if (propertyResult === actions.skip) {
+            continue;
+        }
         if (key === "__proto__") {
-            Object.defineProperty(mut_target.value, key, {
-                value: propertyTarget.value,
+            Object.defineProperty(result, key, {
+                value: propertyResult,
                 configurable: true,
                 enumerable: true,
                 writable: true,
             });
         }
         else {
-            mut_target.value[key] = propertyTarget.value;
+            result[key] = propertyResult;
         }
     }
+    return result;
 }
 /**
- * The default strategy to merge arrays into a target array.
+ * The default strategy to merge arrays.
  *
- * @param mut_target - The result will be mutated into this array
- * @param values - The arrays (including the target's value if there is one).
+ * @param values - The arrays.
  */
-function mergeArraysInto$1(mut_target, values) {
-    mut_target.value.push(...values.slice(1).flat());
+function mergeArrays$1(values) {
+    return values.flat();
 }
 /**
- * The default strategy to merge sets into a target set.
+ * The default strategy to merge sets.
  *
- * @param mut_target - The result will be mutated into this set
- * @param values - The sets (including the target's value if there is one).
+ * @param values - The sets.
  */
-function mergeSetsInto$1(mut_target, values) {
-    for (const value of getIterableOfIterables(values.slice(1))) {
-        mut_target.value.add(value);
-    }
+function mergeSets$1(values) {
+    return new Set(getIterableOfIterables(values));
 }
 /**
- * The default strategy to merge maps into a target map.
+ * The default strategy to merge maps.
  *
- * @param mut_target - The result will be mutated into this map
- * @param values - The maps (including the target's value if there is one).
+ * @param values - The maps.
  */
-function mergeMapsInto$1(mut_target, values) {
-    for (const [key, value] of getIterableOfIterables(values.slice(1))) {
-        mut_target.value.set(key, value);
-    }
+function mergeMaps$1(values) {
+    return new Map(getIterableOfIterables(values));
 }
 /**
- * Set the target to the last value.
+ * Get the last value in the given array.
  */
-function mergeOthersInto$1(mut_target, values) {
-    mut_target.value = values.at(-1);
+function mergeOthers$1(values) {
+    return values.at(-1);
 }
 /**
  * The merge functions.
  */
-const mergeIntoFunctions = {
-    mergeRecords: mergeRecordsInto$1,
-    mergeArrays: mergeArraysInto$1,
-    mergeSets: mergeSetsInto$1,
-    mergeMaps: mergeMapsInto$1,
-    mergeOthers: mergeOthersInto$1,
+const mergeFunctions = {
+    mergeRecords: mergeRecords$1,
+    mergeArrays: mergeArrays$1,
+    mergeSets: mergeSets$1,
+    mergeMaps: mergeMaps$1,
+    mergeOthers: mergeOthers$1,
 };
-
-function deepmergeInto(target, ...objects) {
-    return void deepmergeIntoCustom({})(target, ...objects);
-}
-function deepmergeIntoCustom(options, rootMetaData) {
-    const utils = getIntoUtils(options, customizedDeepmergeInto);
+function deepmergeCustom(options, rootMetaData) {
+    const utils = getUtils(options, customizedDeepmerge);
     /**
      * The customized deepmerge function.
      */
-    function customizedDeepmergeInto(target, ...objects) {
-        mergeUnknownsInto({ value: target }, [target, ...objects], utils, rootMetaData);
+    function customizedDeepmerge(...objects) {
+        return mergeUnknowns(objects, utils, rootMetaData);
     }
-    return customizedDeepmergeInto;
+    return customizedDeepmerge;
 }
 /**
  * The the utils that are available to the merge functions.
  *
  * @param options - The options the user specified
  */
-function getIntoUtils(options, customizedDeepmergeInto) {
+function getUtils(options, customizedDeepmerge) {
     return {
-        defaultMergeFunctions: mergeIntoFunctions,
+        defaultMergeFunctions: mergeFunctions,
         mergeFunctions: {
-            ...mergeIntoFunctions,
+            ...mergeFunctions,
             ...Object.fromEntries(Object.entries(options)
-                .filter(([key, option]) => Object.hasOwn(mergeIntoFunctions, key))
-                .map(([key, option]) => (option === false ? [key, mergeIntoFunctions.mergeOthers] : [key, option]))),
+                .filter(([key, option]) => Object.hasOwn(mergeFunctions, key))
+                .map(([key, option]) => (option === false ? [key, mergeFunctions.mergeOthers] : [key, option]))),
         },
         metaDataUpdater: (options.metaDataUpdater ?? defaultMetaDataUpdater),
-        deepmergeInto: customizedDeepmergeInto,
+        deepmerge: customizedDeepmerge,
+        useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false,
         filterValues: options.filterValues === false ? undefined : (options.filterValues ?? defaultFilterValues),
-        actions: actionsInto,
+        actions,
     };
 }
 /**
- * Merge unknown things into a target.
+ * Merge unknown things.
  *
- * @param mut_target - The target to merge into.
  * @param values - The values.
  */
-function mergeUnknownsInto(mut_target, values, utils, meta) {
+function mergeUnknowns(values, utils, meta) {
     const filteredValues = utils.filterValues?.(values, meta) ?? values;
     if (filteredValues.length === 0) {
-        return;
+        return undefined;
     }
     if (filteredValues.length === 1) {
-        return void mergeOthersInto(mut_target, filteredValues, utils, meta);
+        return mergeOthers(filteredValues, utils, meta);
     }
-    const type = getObjectType(mut_target.value);
+    const type = getObjectType(filteredValues[0]);
     if (type !== 0 /* ObjectType.NOT */ && type !== 5 /* ObjectType.OTHER */) {
         for (let mut_index = 1; mut_index < filteredValues.length; mut_index++) {
             if (getObjectType(filteredValues[mut_index]) === type) {
                 continue;
             }
-            return void mergeOthersInto(mut_target, filteredValues, utils, meta);
+            return mergeOthers(filteredValues, utils, meta);
         }
     }
     switch (type) {
         case 1 /* ObjectType.RECORD */: {
-            return void mergeRecordsInto(mut_target, filteredValues, utils, meta);
+            return mergeRecords(filteredValues, utils, meta);
         }
         case 2 /* ObjectType.ARRAY */: {
-            return void mergeArraysInto(mut_target, filteredValues, utils, meta);
+            return mergeArrays(filteredValues, utils, meta);
         }
         case 3 /* ObjectType.SET */: {
-            return void mergeSetsInto(mut_target, filteredValues, utils, meta);
+            return mergeSets(filteredValues, utils, meta);
         }
         case 4 /* ObjectType.MAP */: {
-            return void mergeMapsInto(mut_target, filteredValues, utils, meta);
+            return mergeMaps(filteredValues, utils, meta);
         }
         default: {
-            return void mergeOthersInto(mut_target, filteredValues, utils, meta);
+            return mergeOthers(filteredValues, utils, meta);
         }
     }
 }
 /**
- * Merge records into a target record.
+ * Merge records.
  *
- * @param mut_target - The target to merge into.
  * @param values - The records.
  */
-function mergeRecordsInto(mut_target, values, utils, meta) {
-    const action = utils.mergeFunctions.mergeRecords(mut_target, values, utils, meta);
-    if (action === actionsInto.defaultMerge) {
-        utils.defaultMergeFunctions.mergeRecords(mut_target, values, utils, meta);
+function mergeRecords(values, utils, meta) {
+    const result = utils.mergeFunctions.mergeRecords(values, utils, meta);
+    if (result === actions.defaultMerge ||
+        (utils.useImplicitDefaultMerging &&
+            result === undefined &&
+            utils.mergeFunctions.mergeRecords !== utils.defaultMergeFunctions.mergeRecords)) {
+        return utils.defaultMergeFunctions.mergeRecords(values, utils, meta);
     }
+    return result;
 }
 /**
- * Merge arrays into a target array.
+ * Merge arrays.
  *
- * @param mut_target - The target to merge into.
  * @param values - The arrays.
  */
-function mergeArraysInto(mut_target, values, utils, meta) {
-    const action = utils.mergeFunctions.mergeArrays(mut_target, values, utils, meta);
-    if (action === actionsInto.defaultMerge) {
-        utils.defaultMergeFunctions.mergeArrays(mut_target, values);
+function mergeArrays(values, utils, meta) {
+    const result = utils.mergeFunctions.mergeArrays(values, utils, meta);
+    if (result === actions.defaultMerge ||
+        (utils.useImplicitDefaultMerging &&
+            result === undefined &&
+            utils.mergeFunctions.mergeArrays !== utils.defaultMergeFunctions.mergeArrays)) {
+        return utils.defaultMergeFunctions.mergeArrays(values);
     }
+    return result;
 }
 /**
- * Merge sets into a target set.
+ * Merge sets.
  *
- * @param mut_target - The target to merge into.
  * @param values - The sets.
  */
-function mergeSetsInto(mut_target, values, utils, meta) {
-    const action = utils.mergeFunctions.mergeSets(mut_target, values, utils, meta);
-    if (action === actionsInto.defaultMerge) {
-        utils.defaultMergeFunctions.mergeSets(mut_target, values);
+function mergeSets(values, utils, meta) {
+    const result = utils.mergeFunctions.mergeSets(values, utils, meta);
+    if (result === actions.defaultMerge ||
+        (utils.useImplicitDefaultMerging &&
+            result === undefined &&
+            utils.mergeFunctions.mergeSets !== utils.defaultMergeFunctions.mergeSets)) {
+        return utils.defaultMergeFunctions.mergeSets(values);
     }
+    return result;
 }
 /**
- * Merge maps into a target map.
+ * Merge maps.
  *
- * @param mut_target - The target to merge into.
  * @param values - The maps.
  */
-function mergeMapsInto(mut_target, values, utils, meta) {
-    const action = utils.mergeFunctions.mergeMaps(mut_target, values, utils, meta);
-    if (action === actionsInto.defaultMerge) {
-        utils.defaultMergeFunctions.mergeMaps(mut_target, values);
+function mergeMaps(values, utils, meta) {
+    const result = utils.mergeFunctions.mergeMaps(values, utils, meta);
+    if (result === actions.defaultMerge ||
+        (utils.useImplicitDefaultMerging &&
+            result === undefined &&
+            utils.mergeFunctions.mergeMaps !== utils.defaultMergeFunctions.mergeMaps)) {
+        return utils.defaultMergeFunctions.mergeMaps(values);
     }
+    return result;
 }
 /**
- * Merge other things into a target.
+ * Merge other things.
  *
- * @param mut_target - The target to merge into.
  * @param values - The other things.
  */
-function mergeOthersInto(mut_target, values, utils, meta) {
-    const action = utils.mergeFunctions.mergeOthers(mut_target, values, utils, meta);
-    if (action === actionsInto.defaultMerge || mut_target.value === actionsInto.defaultMerge) {
-        utils.defaultMergeFunctions.mergeOthers(mut_target, values);
+function mergeOthers(values, utils, meta) {
+    const result = utils.mergeFunctions.mergeOthers(values, utils, meta);
+    if (result === actions.defaultMerge ||
+        (utils.useImplicitDefaultMerging &&
+            result === undefined &&
+            utils.mergeFunctions.mergeOthers !== utils.defaultMergeFunctions.mergeOthers)) {
+        return utils.defaultMergeFunctions.mergeOthers(values);
     }
+    return result;
 }
 
 /** @type {import("@/types").Template} */
@@ -398,6 +401,20 @@ const lite = {
     widget: {
       name: "EodashMap",
       properties: {
+        baseLayers: [
+          {
+            type: "Tile",
+            properties: {
+              id: "terrain-light;:;EPSG:3857",
+              title: "Terrain Light",
+            },
+            source: {
+              type: "XYZ",
+              //@ts-expect-error todo
+              url: "https://s2maps-tiles.eu/wmts/1.0.0/terrain-light_3857/default/g/{z}/{y}/{x}.jpeg",
+            },
+          },
+        ],
         enableCompare: true,
         enableCursorCoordinates: false,
         enableScaleLine: false,
@@ -535,6 +552,29 @@ const expert = {
     widget: {
       name: "EodashMap",
       properties: {
+        baseLayers: [
+          {
+            type: "Group",
+            properties: {
+              id: "BaseLayersGroup",
+              title: "Base Layers",
+            },
+            layers: [
+              {
+                type: "Tile",
+                properties: {
+                  id: "terrain-light;:;EPSG:3857",
+                  title: "Terrain Light",
+                },
+                source: {
+                  type: "XYZ",
+                  //@ts-expect-error todo
+                  url: "https://s2maps-tiles.eu/wmts/1.0.0/terrain-light_3857/default/g/{z}/{y}/{x}.jpeg",
+                },
+              },
+            ],
+          },
+        ],
         enableCompare: true,
         zoomToExtent: true,
         btns: {
@@ -681,6 +721,29 @@ const compare = {
       name: "EodashMap",
       properties: {
         enableCompare: true,
+        baseLayers: [
+          {
+            type: "Group",
+            properties: {
+              id: "BaseLayersGroup",
+              title: "Base Layers",
+            },
+            layers: [
+              {
+                type: "Tile",
+                properties: {
+                  id: "terrain-light;:;EPSG:3857",
+                  title: "Terrain Light",
+                },
+                source: {
+                  type: "XYZ",
+                  //@ts-expect-error todo
+                  url: "https://s2maps-tiles.eu/wmts/1.0.0/terrain-light_3857/default/g/{z}/{y}/{x}.jpeg",
+                },
+              },
+            ],
+          },
+        ],
       },
     },
   },
@@ -774,6 +837,26 @@ const compare = {
           },
         },
     },
+    // {
+    //   defineWidget: (selectedSTAC) => {
+    //     return selectedSTAC
+    //       ? {
+    //           id: "expert-Datepicker",
+    //           type: "internal",
+    //           layout: { x: 4, y: 7, w: 4, h: 5 },
+    //           title: "Date",
+    //           widget: {
+    //             name: "EodashDatePicker",
+    //             properties: {
+    //               hintText: `<b>Hint:</b> closest available date is displayed <br />
+    //                             on map (see Analysis Layers)`,
+    //               toggleCalendar: true,
+    //             },
+    //           },
+    //         }
+    //       : null;
+    //   },
+    // },
     {
       defineWidget: () =>
         shouldShowChartWidget() && {
@@ -805,16 +888,28 @@ const compare = {
       defineWidget: (selectedSTAC) => {
         return selectedSTAC
           ? {
-              id: "expert-Datepicker",
+              id: "expert-datetime",
               type: "internal",
-              layout: { x: 4, y: 3, w: 4, h: 9 },
-              title: "Date",
+              layout: { x: 1, y: 8, w: 8, h: 3 },
+              title: "Time Slider",
               widget: {
-                name: "EodashDatePicker",
+                name: "EodashTimeSlider",
                 properties: {
-                  hintText: `<b>Hint:</b> closest available date is displayed<br/>
-                                on map (see Analysis Layers)`,
-                  toggleCalendar: true,
+                  filters: [
+                    {
+                      key: "eo:cloud_cover",
+                      title: "Cloud Coverage %",
+                      type: "range",
+                      expanded: true,
+                      min: 0,
+                      max: 100,
+                      step: 5,
+                      state: {
+                        min: 0,
+                        max: 100,
+                      },
+                    },
+                  ],
                 },
               },
             }
@@ -824,7 +919,6 @@ const compare = {
   ],
 };
 
-// import { includesProcess } from "@/store/actions";
 /** @type {import("@/types").Template} */
 const explore = {
   gap: 16,
@@ -849,6 +943,7 @@ const explore = {
     widget: {
       name: "EodashMap",
       properties: {
+        zoomToExtent: false,
         enableCompare: true,
         btns: {
           enableZoom: true,
@@ -856,21 +951,23 @@ const explore = {
           enableChangeProjection: true,
           enableCompareIndicators: {
             fallbackTemplate: "explore",
+            compareTemplate: "compare",
             itemFilterConfig: {
               imageProperty: "assets.thumbnail.href",
             },
           },
-          enableSearch: true,
+          enableBackToPOIs: false,
+          enableSearch: false,
         },
       },
     },
   },
   widgets: [
     {
-      id: "Layercontrol",
+      id: "explore-layercontrol",
       type: "internal",
       title: "Layers",
-      layout: { x: "9/9/10", y: 0, w: "3/3/2", h: 12 },
+      layout: { x: "9/9/10", y: 0, w: "3/3/2", h: 11 },
       widget: {
         name: "EodashLayerControl",
       },
@@ -879,9 +976,13 @@ const explore = {
       id: "ItemCatalog",
       title: "Catalog",
       type: "internal",
-      layout: { x: 0, y: 0, w: "3/3/2", h: 12 },
+      layout: { x: 0, y: 0, w: "3/3/2", h: 11 },
       widget: {
         name: "EodashItemCatalog",
+        properties: {
+          layoutTarget: undefined,
+          hoverProperties: ["datetime", "eo:cloud_cover"],
+        },
       },
     },
   ],
@@ -896,12 +997,14 @@ const baseConfig = {
   stacEndpoint: {
     endpoint:
       "https://esa-eodashboards.github.io/eodashboard-catalog/trilateral/catalog.json",
+    // "https://GTIF-Austria.github.io/public-catalog/pr-preview/pr-119/GTIF-Austria/catalog.json",
     // "https://api.explorer.eopf.copernicus.eu/stac",
     // api: true,
     supportedUpscalingEndpoints: [
-      "openveda.cloud",
-      "api.explorer.eopf.copernicus.eu",
+      { url: "openveda.cloud", titilerVersion: 1 },
+      { url: "api.explorer.eopf.copernicus.eu", titilerVersion: 2 },
     ],
+    rasterEndpoint: "https://api.explorer.eopf.copernicus.eu/rstaging",
   },
   brand: {
     noLayout: true,
@@ -949,13 +1052,41 @@ const baseConfig = {
   },
 };
 
+/**
+ * Arrays are replacement semantics (user array wins, not concat).
+ * mergeArrays:false ensures e.g. widgets/collectionsPalette/supportedUpscalingEndpoints
+ * supplied by the caller fully replace the base arrays.
+ */
+const deepmerge = deepmergeCustom({ mergeArrays: false });
+
 /**
  * @param {import("vega-lite").DeepPartial<import("@/types").Eodash>} config
+ * @return {import("@/types").Eodash}
  */
 const getBaseConfig = (config) => {
-  const merged = /** @type {import("@/types").Eodash} */ ({});
-  deepmergeInto(merged, baseConfig, config || {});
-  return merged;
+  return /** @type {import("@/types").Eodash} */ (
+    deepmerge(cloneConfig(baseConfig), config || {})
+  );
 };
 
+/**
+ * Shallow-safe deep clone that preserves functions and Symbols as references
+ * (they are intentionally shared; template functions and Symbol IDs are
+ * not mutable data). Only plain objects and arrays are cloned.
+ *
+ * @param {unknown} val
+ * @returns {unknown}
+ */
+function cloneConfig(val) {
+  if (val === null || typeof val !== "object") return val;
+  if (Array.isArray(val)) return val.map(cloneConfig);
+  if (typeof val === "function") return val;
+  /** @type {Record<string, unknown>} */
+  const out = {};
+  for (const key of Object.keys(val)) {
+    out[key] = cloneConfig(/** @type {Record<string, unknown>} */ (val)[key]);
+  }
+  return out;
+}
+
 export { compare, getBaseConfig as default, expert, explore, getBaseConfig, lite };

package/dist/client/{transition-OHcz5Qq1.js → transition-D_W6Wn9v.js}

@@ -1,5 +1,5 @@
 import { mergeProps, h, TransitionGroup, Transition } from 'vue';
-import { p as propsFactory, a0 as isObject, aH as onlyDefinedProps } from './asWebComponent-BHWpMuE3.js';
+import { p as propsFactory, ag as isObject, aQ as onlyDefinedProps } from './asWebComponent-BlFN2lkB.js';
 
 // Utilities
 const makeTransitionProps = propsFactory({