@eodash/eodash 5.6.1 → 5.7.1

package/dist/client/{async-CIbKXEEe.js → async-B2H8ZwUK.js}

@@ -1,5 +1,5 @@
-import { t as replaceLayer, b as extractLayerConfig, x as extractLayerLegend, m as mergeGeojsons, d as axios, w as getCompareLayers, v as getLayers, $ as axios$1, I as compareIndicator, F as indicator } from './helpers-DAVGYl_f.js';
-import { S as useEmitLayersUpdate } from './asWebComponent-DfULAbpq.js';
+import { y as replaceLayer, d as extractLayerConfig, C as extractLayerLegend, m as mergeGeojsons, f as axios, ab as getCompareLayers, B as getLayers, ae as axios$1, Q as compareIndicator, M as indicator } from './helpers-CBqIUSXJ.js';
+import { aa as useEmitLayersUpdate } from './asWebComponent-BlFN2lkB.js';
 import { isMulti } from '@eox/jsonform/src/custom-inputs/spatial/utils';
 import log from 'loglevel';
 
@@ -649,16 +649,27 @@ async function updateJobsStatus(jobs, indicator) {
     jobsUrls.map((url) =>
       axios$1
         .get(url, { params: { t: Date.now() } })
-        .then((response) => response.data),
+        .then((response) => response.data)
+        .catch((error) => {
+          if (axios$1.isAxiosError(error)) {
+            console.warn(
+              `Job URL not accessible: ${url}. Maybe was deleted from the processing endpoint or endpoint is unavailable. Skipping...`,
+            );
+            return null;
+          }
+          throw error;
+        }),
     ),
   );
-  jobResults.sort((a, b) => {
-    return (
-      new Date(b.job_start_datetime).getTime() -
-      new Date(a.job_start_datetime).getTime()
-    );
-  });
-  jobs.value.splice(0, jobs.value.length, ...jobResults);
+  const validResults = jobResults
+    .filter((job) => job !== null)
+    .sort((a, b) => {
+      return (
+        new Date(b.job_start_datetime).getTime() -
+        new Date(a.job_start_datetime).getTime()
+      );
+    });
+  jobs.value.splice(0, jobs.value.length, ...validResults);
 }
 
 /**

package/dist/client/create-layers-config-u_vn5hPk.js

@@ -0,0 +1,182 @@
+import { ah as EodashCollection } from './asWebComponent-BlFN2lkB.js';
+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 | import("stac-ts").StacItem | null} [timeOrItem] - time as a string, or a stac item
+ * @param {Record<string, any>[]} [defaultBaseLayers] - Optional default baselayers to use if the indicator does not provide any
+ * @returns {Promise<Record<string, any>[]>}
+ */
+
+const createLayersConfig = async (
+  selectedIndicator,
+  eodashCols,
+  timeOrItem,
+  defaultBaseLayers = [],
+) => {
+  log.debug(
+    "Creating layers config",
+    selectedIndicator,
+    eodashCols,
+    timeOrItem,
+  );
+  const layersCollection = [];
+  const dataLayers = {
+    type: "Group",
+    properties: {
+      id: "AnalysisGroup",
+      title: "Data Layers",
+      layerControlExpand: true,
+    },
+    layers: /** @type {Record<string,any>[]}*/ ([]),
+  };
+
+  for (const ec of eodashCols) {
+    /** @type {Record<string,any>[]} */
+    let layers;
+    let dateOrItem;
+    if (timeOrItem) {
+      if (typeof timeOrItem === "string" && timeOrItem.includes("/")) {
+        dateOrItem = timeOrItem;
+      } else {
+        dateOrItem =
+          typeof timeOrItem === "string" ? new Date(timeOrItem) : timeOrItem;
+      }
+      layers = await ec.createLayersJson(/** @type {any} */ (dateOrItem));
+    } else {
+      layers = await ec.createLayersJson(undefined);
+    }
+
+    // Add expand to all analysis layers
+    layers.forEach((dl) => {
+      if (!dl.properties?.layerControlExclusive) {
+        dl.properties.layerControlExpand = true;
+        dl.properties.layerControlToolsExpand = true;
+      }
+    });
+    dataLayers.layers.push(...layers);
+  }
+
+  /* check for roles in indicator links to assign visibility property for the data layers */
+  if (selectedIndicator?.links) {
+    const visibilityLinks = selectedIndicator.links.filter(
+      (link) =>
+        Array.isArray(link.roles) &&
+        (link.roles.includes("disable") || link.roles.includes("hidden")),
+    );
+    if (visibilityLinks.length > 0) {
+      visibilityLinks.forEach((vl) => {
+        const targetLayerId = vl.id;
+        const targetLayer = dataLayers.layers.find(
+          (dl) => dl.properties.id.split(";:;")[0] === targetLayerId,
+        );
+        if (targetLayer) {
+          if (Array.isArray(vl.roles) && vl.roles.includes("disable")) {
+            targetLayer.properties.visible = false;
+            targetLayer.properties.layerControlExpand = false;
+          } else if (Array.isArray(vl.roles) && vl.roles.includes("hidden")) {
+            targetLayer.properties.layerControlHide = true;
+          }
+        }
+      });
+    }
+  }
+  layersCollection.push(dataLayers);
+  const indicatorLayers =
+    //@ts-expect-error indicator is collection
+    await EodashCollection.getIndicatorLayers(selectedIndicator);
+  const observationPointsLayer =
+    EodashCollection.getObservationPointsLayer(eodashCols);
+  if (observationPointsLayer) {
+    dataLayers.layers.push(observationPointsLayer);
+  }
+  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(...defaultBaseLayers);
+  }
+
+  if (baseLayers.layers.length) {
+    layersCollection.unshift(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.push(overlayLayers);
+  }
+
+  return layersCollection;
+};
+
+export { createLayersConfig as c };

package/dist/client/dialog-transition-BrMkMiNa.js

@@ -0,0 +1,170 @@
+import { createVNode, Transition, mergeProps } from 'vue';
+import { g as genericComponent, ar as PREFERS_REDUCED_MOTION, p as propsFactory, at as getTargetBox, au as acceleratedEasing, av as deceleratedEasing, aw as standardEasing } from './asWebComponent-BlFN2lkB.js';
+import { b as animate, n as nullifyTransforms } from './forwardRefs-DAlror6d.js';
+
+// Utilities
+const makeVDialogTransitionProps = propsFactory({
+  target: [Object, Array]
+}, 'v-dialog-transition');
+const saved = new WeakMap();
+const VDialogTransition = genericComponent()({
+  name: 'VDialogTransition',
+  props: makeVDialogTransitionProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const functions = {
+      onBeforeEnter(el) {
+        el.style.pointerEvents = 'none';
+        el.style.visibility = 'hidden';
+      },
+      async onEnter(el, done) {
+        await new Promise(resolve => requestAnimationFrame(resolve));
+        await new Promise(resolve => requestAnimationFrame(resolve));
+        el.style.visibility = '';
+        const dimensions = getDimensions(props.target, el);
+        const {
+          x,
+          y,
+          sx,
+          sy,
+          speed
+        } = dimensions;
+        saved.set(el, dimensions);
+        if (PREFERS_REDUCED_MOTION()) {
+          animate(el, [{
+            opacity: 0
+          }, {}], {
+            duration: 125 * speed,
+            easing: deceleratedEasing
+          }).finished.then(() => done());
+        } else {
+          const animation = animate(el, [{
+            transform: `translate(${x}px, ${y}px) scale(${sx}, ${sy})`,
+            opacity: 0
+          }, {}], {
+            duration: 225 * speed,
+            easing: deceleratedEasing
+          });
+          getChildren(el)?.forEach(el => {
+            animate(el, [{
+              opacity: 0
+            }, {
+              opacity: 0,
+              offset: 0.33
+            }, {}], {
+              duration: 225 * 2 * speed,
+              easing: standardEasing
+            });
+          });
+          animation.finished.then(() => done());
+        }
+      },
+      onAfterEnter(el) {
+        el.style.removeProperty('pointer-events');
+      },
+      onBeforeLeave(el) {
+        el.style.pointerEvents = 'none';
+      },
+      async onLeave(el, done) {
+        await new Promise(resolve => requestAnimationFrame(resolve));
+        let dimensions;
+        if (!saved.has(el) || Array.isArray(props.target) || props.target.offsetParent || props.target.getClientRects().length) {
+          dimensions = getDimensions(props.target, el);
+        } else {
+          dimensions = saved.get(el);
+        }
+        const {
+          x,
+          y,
+          sx,
+          sy,
+          speed
+        } = dimensions;
+        if (PREFERS_REDUCED_MOTION()) {
+          animate(el, [{}, {
+            opacity: 0
+          }], {
+            duration: 85 * speed,
+            easing: acceleratedEasing
+          }).finished.then(() => done());
+        } else {
+          const animation = animate(el, [{}, {
+            transform: `translate(${x}px, ${y}px) scale(${sx}, ${sy})`,
+            opacity: 0
+          }], {
+            duration: 125 * speed,
+            easing: acceleratedEasing
+          });
+          animation.finished.then(() => done());
+          getChildren(el)?.forEach(el => {
+            animate(el, [{}, {
+              opacity: 0,
+              offset: 0.2
+            }, {
+              opacity: 0
+            }], {
+              duration: 125 * 2 * speed,
+              easing: standardEasing
+            });
+          });
+        }
+      },
+      onAfterLeave(el) {
+        el.style.removeProperty('pointer-events');
+      }
+    };
+    return () => {
+      return props.target ? createVNode(Transition, mergeProps({
+        "name": "dialog-transition"
+      }, functions, {
+        "css": false
+      }), slots) : createVNode(Transition, {
+        "name": "dialog-transition"
+      }, slots);
+    };
+  }
+});
+
+/** Animatable children (card, sheet, list) */
+function getChildren(el) {
+  const els = el.querySelector(':scope > .v-card, :scope > .v-sheet, :scope > .v-list')?.children;
+  return els && [...els];
+}
+function getDimensions(target, el) {
+  const targetBox = getTargetBox(target);
+  const elBox = nullifyTransforms(el);
+  const [originX, originY] = getComputedStyle(el).transformOrigin.split(' ').map(v => parseFloat(v));
+  const [anchorSide, anchorOffset] = getComputedStyle(el).getPropertyValue('--v-overlay-anchor-origin').split(' ');
+  let offsetX = targetBox.left + targetBox.width / 2;
+  if (anchorSide === 'left' || anchorOffset === 'left') {
+    offsetX -= targetBox.width / 2;
+  } else if (anchorSide === 'right' || anchorOffset === 'right') {
+    offsetX += targetBox.width / 2;
+  }
+  let offsetY = targetBox.top + targetBox.height / 2;
+  if (anchorSide === 'top' || anchorOffset === 'top') {
+    offsetY -= targetBox.height / 2;
+  } else if (anchorSide === 'bottom' || anchorOffset === 'bottom') {
+    offsetY += targetBox.height / 2;
+  }
+  const tsx = targetBox.width / elBox.width;
+  const tsy = targetBox.height / elBox.height;
+  const maxs = Math.max(1, tsx, tsy);
+  const sx = tsx / maxs || 0;
+  const sy = tsy / maxs || 0;
+
+  // Animate elements larger than 12% of the screen area up to 1.5x slower
+  const asa = elBox.width * elBox.height / (window.innerWidth * window.innerHeight);
+  const speed = asa > 0.12 ? Math.min(1.5, (asa - 0.12) * 10 + 1) : 1;
+  return {
+    x: offsetX - (originX + elBox.left),
+    y: offsetY - (originY + elBox.top),
+    sx,
+    sy,
+    speed
+  };
+}
+
+export { VDialogTransition as V };

package/dist/client/eo-dash.js

@@ -1,2 +1,2 @@
-export { aI as EodashConstructor, aJ as register, aK as store } from './asWebComponent-DfULAbpq.js';
+export { aR as EodashConstructor, aS as register, aT as store } from './asWebComponent-BlFN2lkB.js';
 import 'vue';

package/dist/client/{forwardRefs-yj3VWOK5.js → forwardRefs-DAlror6d.js}

@@ -1,84 +1,6 @@
 import { computed, watch, onScopeDispose, nextTick, ref, watchEffect, effectScope, inject, mergeProps, toRef, toValue, shallowRef, onMounted, reactive, provide, toRaw, readonly, warn, onBeforeUnmount, createElementVNode, Fragment, createVNode, Teleport, withDirectives, vShow, Transition } from 'vue';
-import { aq as isOn, ar as eventName, p as propsFactory, as as destructComputed, at as parseAnchor, au as flipSide, av as flipAlign, aw as flipCorner, ax as CircularBuffer, ay as deepEqual, a0 as consoleError, az as getAxis, q as convertToUnit, x as clamp, aA as IN_BROWSER, A as useToggleScope, aB as defer, al as getCurrentInstance, aC as templateRef, aD as matchesSelector, aE as focusableChildren, G as useDisplay, r as makeThemeProps, d as makeDimensionProps, e as makeComponentProps, g as genericComponent, z as useProxiedModel, l as provideTheme, n as useRtl, f as useBackgroundColor, b as useDimension, aF as useRouter, aG as useBackButton, ao as standardEasing, c as useRender, C as omit } from './asWebComponent-DfULAbpq.js';
-import { m as makeTransitionProps, M as MaybeTransition } from './transition-DaOsiD4u.js';
-
-class Box {
-  constructor(args) {
-    const pageScale = document.body.currentCSSZoom ?? 1;
-    const isElement = args instanceof Element;
-    const factor = isElement ? 1 + (1 - pageScale) / pageScale : 1;
-    const {
-      x,
-      y,
-      width,
-      height
-    } = isElement ? args.getBoundingClientRect() : args;
-    this.x = x * factor;
-    this.y = y * factor;
-    this.width = width * factor;
-    this.height = height * factor;
-  }
-  get top() {
-    return this.y;
-  }
-  get bottom() {
-    return this.y + this.height;
-  }
-  get left() {
-    return this.x;
-  }
-  get right() {
-    return this.x + this.width;
-  }
-}
-function getOverflow(a, b) {
-  return {
-    x: {
-      before: Math.max(0, b.left - a.left),
-      after: Math.max(0, a.right - b.right)
-    },
-    y: {
-      before: Math.max(0, b.top - a.top),
-      after: Math.max(0, a.bottom - b.bottom)
-    }
-  };
-}
-function getTargetBox(target) {
-  if (Array.isArray(target)) {
-    const pageScale = document.body.currentCSSZoom ?? 1;
-    const factor = 1 + (1 - pageScale) / pageScale;
-    return new Box({
-      x: target[0] * factor,
-      y: target[1] * factor,
-      width: 0 * factor,
-      height: 0 * factor
-    });
-  } else {
-    return new Box(target);
-  }
-}
-function getElementBox(el) {
-  if (el === document.documentElement) {
-    if (!visualViewport) {
-      return new Box({
-        x: 0,
-        y: 0,
-        width: document.documentElement.clientWidth,
-        height: document.documentElement.clientHeight
-      });
-    } else {
-      const pageScale = document.body.currentCSSZoom ?? 1;
-      return new Box({
-        x: visualViewport.scale > 1 ? 0 : visualViewport.offsetLeft,
-        y: visualViewport.scale > 1 ? 0 : visualViewport.offsetTop,
-        width: visualViewport.width * visualViewport.scale / pageScale,
-        height: visualViewport.height * visualViewport.scale / pageScale
-      });
-    }
-  } else {
-    return new Box(el);
-  }
-}
+import { ax as Box, ay as isOn, az as eventName, p as propsFactory, aA as destructComputed, aB as parseAnchor, aC as flipSide, aD as flipAlign, aE as flipCorner, aF as CircularBuffer, aG as deepEqual, at as getTargetBox, aH as getElementBox, O as consoleError, aI as getAxis, q as convertToUnit, aJ as getOverflow, x as clamp, aK as IN_BROWSER, A as useToggleScope, aL as defer, N as getCurrentInstance, aM as templateRef, aN as matchesSelector, a8 as focusableChildren, G as useDisplay, r as makeThemeProps, d as makeDimensionProps, e as makeComponentProps, g as genericComponent, z as useProxiedModel, l as provideTheme, n as useRtl, f as useBackgroundColor, b as useDimension, aO as useRouter, aP as useBackButton, aw as standardEasing, c as useRender, C as omit } from './asWebComponent-BlFN2lkB.js';
+import { m as makeTransitionProps, M as MaybeTransition } from './transition-D_W6Wn9v.js';
 
 // Utilities
 /** @see https://stackoverflow.com/a/57876601/2074736 */
@@ -1161,7 +1083,7 @@ function useActivator(props, _ref) {
   });
   watch(isTop, val => {
     if (val && (props.openOnHover && !isHovered && (!openOnFocus.value || !isFocused) || openOnFocus.value && !isFocused && (!props.openOnHover || !isHovered)) && !contentEl.value?.contains(document.activeElement)) {
-      isActive.value = false;
+      runCloseDelay();
     }
   });
   watch(isActive, val => {
@@ -1356,7 +1278,7 @@ function useFocusTrap(props, _ref2) {
     const after = e.target;
     document.removeEventListener('pointerdown', onPointerdown);
     document.removeEventListener('keydown', captureOnKeydown);
-    await nextTick();
+    await new Promise(resolve => requestAnimationFrame(resolve));
     if (isActive.value && !focusTrapSuppressed && before !== after && contentEl.value &&
     // We're the menu without open submenus or overlays
     toValue(localTop) &&
@@ -1737,13 +1659,12 @@ const VOverlay = genericComponent()({
     }
     const router = useRouter();
     useToggleScope(() => props.closeOnBack, () => {
-      useBackButton(router, next => {
+      useBackButton(router, () => {
         if (globalTop.value && isActive.value) {
-          next(false);
           if (!props.persistent) isActive.value = false;else animateClick();
-        } else {
-          next();
+          return false;
         }
+        return undefined;
       });
     });
     const top = ref();
@@ -1935,4 +1856,4 @@ function forwardRefs(target) {
   });
 }
 
-export { VOverlay as V, animate as a, forwardRefs as f, getTargetBox as g, makeVOverlayProps as m, nullifyTransforms as n, useScopeId as u };
+export { VMenuSymbol as V, VOverlay as a, animate as b, forwardRefs as f, makeVOverlayProps as m, nullifyTransforms as n, useScopeId as u };