@eodash/eodash 5.3.3 → 5.5.0

package/dist/client/{async-D1MvO_Z_.js → async-D6Lvv-fT.js}

@@ -1,5 +1,5 @@
-import { q as getCompareLayers, p as getLayers, V as replaceLayer, a as extractLayerConfig, w as extractLayerLegend, m as mergeGeojsons, j as axios, W as axios$1, H as compareIndicator, F as indicator } from './helpers-CtUlAW0N.js';
-import { P as useEmitLayersUpdate } from './asWebComponent-DdguWGDI.js';
+import { x as getCompareLayers, w as getLayers, $ as replaceLayer, b as extractLayerConfig, v as extractLayerLegend, m as mergeGeojsons, d as axios, a0 as axios$1, I as compareIndicator, G as indicator } from './helpers-BBSdbOmv.js';
+import { P as useEmitLayersUpdate } from './asWebComponent-DaIxULaA.js';
 import { isMulti } from '@eox/jsonform/src/custom-inputs/spatial/utils';
 import log from 'loglevel';
 
@@ -502,6 +502,16 @@ function extractAsyncResults(resultItem) {
   }
   return extracted;
 }
+
+/** @param {*} jsonformSchema */
+const getDrawToolsProperty = (jsonformSchema) => {
+  for (const property in jsonformSchema.properties) {
+    if (jsonformSchema.properties[property]?.options?.drawtools) {
+      return property;
+    }
+  }
+};
+
 /**
  * @param {import("@eox/map").EOxMap | null} mapElement
  * @param {import("@eox/map").EoxLayer[]} processLayers
@@ -527,7 +537,7 @@ const applyProcessLayersToMap = (mapElement, processLayers) => {
       (l) => l.properties?.id === layer.properties?.id,
     );
     if (!exists) {
-      analysisGroup.layers.unshift(layer);
+      analysisGroup.layers.push(layer);
     } else {
       analysisGroup.layers = replaceLayer(
         analysisGroup.layers,
@@ -669,7 +679,7 @@ async function updateJobsStatus(jobs, indicator) {
       new Date(a.job_start_datetime).getTime()
     );
   });
-  jobs.value = jobResults;
+  jobs.value.splice(0, jobs.value.length, ...jobResults);
 }
 
 /**
@@ -801,4 +811,4 @@ const getJobStatusUrl = (jobID, indicator) => {
   return jobUrl;
 };
 
-export { creatAsyncProcessLayerDefinitions as a, generateTimePairs as b, createTiffLayerDefinition as c, download as d, extractAsyncResults as e, updateJsonformSchemaTarget as f, getBboxProperty as g, extractGeometries as h, applyProcessLayersToMap as i, getJobStatusUrl as j, downloadPreviousResults as k, loadProcess as l, deleteJob as m, pollProcessStatus as p, separateEndpointLinks as s, updateJobsStatus as u };
+export { creatAsyncProcessLayerDefinitions as a, getBboxProperty as b, createTiffLayerDefinition as c, download as d, extractAsyncResults as e, generateTimePairs as f, getDrawToolsProperty as g, updateJsonformSchemaTarget as h, extractGeometries as i, applyProcessLayersToMap as j, getJobStatusUrl as k, loadProcess as l, downloadPreviousResults as m, deleteJob as n, pollProcessStatus as p, separateEndpointLinks as s, updateJobsStatus as u };

package/dist/client/eo-dash.js

@@ -1,2 +1,2 @@
-export { aI as EodashConstructor, aH as register, aJ as store } from './asWebComponent-DdguWGDI.js';
+export { aJ as EodashConstructor, aI as register, aK as store } from './asWebComponent-DaIxULaA.js';
 import 'vue';

package/dist/client/{forwardRefs-DM-E2MfG.js → forwardRefs--IccUBdR.js}

@@ -1,17 +1,18 @@
-import { computed, watch, onScopeDispose, nextTick, ref, watchEffect, effectScope, inject, mergeProps, shallowRef, onMounted, toRef, reactive, provide, toValue, toRaw, readonly, warn, onBeforeUnmount, createElementVNode, Fragment, createVNode, Teleport, withDirectives, vShow, Transition } from 'vue';
-import { ar as isOn, as as eventName, p as propsFactory, at as destructComputed, au as parseAnchor, av as flipSide, aw as flipAlign, ax as flipCorner, ay as CircularBuffer, az as deepEqual, X as consoleError, aA as getAxis, o as convertToUnit, v as clamp, ao as IN_BROWSER, y as useToggleScope, aB as defer, ak as getCurrentInstance, aC as templateRef, aD as matchesSelector, D as useDisplay, q as makeThemeProps, d as makeDimensionProps, e as makeComponentProps, g as genericComponent, x as useProxiedModel, k as provideTheme, l as useRtl, f as useBackgroundColor, b as useDimension, aE as useRouter, aF as useBackButton, an as standardEasing, c as useRender } from './asWebComponent-DdguWGDI.js';
-import { m as makeTransitionProps, M as MaybeTransition } from './transition-BdzATvPB.js';
+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, Y as consoleError, az as getAxis, o as convertToUnit, v as clamp, aA as IN_BROWSER, y as useToggleScope, aB as defer, al as getCurrentInstance, aC as templateRef, aD as matchesSelector, aE as focusableChildren, D as useDisplay, q as makeThemeProps, d as makeDimensionProps, e as makeComponentProps, g as genericComponent, $ as omit, x as useProxiedModel, k as provideTheme, l as useRtl, f as useBackgroundColor, b as useDimension, aF as useRouter, aG as useBackButton, ao as standardEasing, c as useRender } from './asWebComponent-DaIxULaA.js';
+import { m as makeTransitionProps, M as MaybeTransition } from './transition-DFr4cXu8.js';
 
 class Box {
   constructor(args) {
     const pageScale = document.body.currentCSSZoom ?? 1;
-    const factor = args instanceof DOMRect ? 1 + (1 - pageScale) / pageScale : 1;
+    const isElement = args instanceof Element;
+    const factor = isElement ? 1 + (1 - pageScale) / pageScale : 1;
     const {
       x,
       y,
       width,
       height
-    } = args;
+    } = isElement ? args.getBoundingClientRect() : args;
     this.x = x * factor;
     this.y = y * factor;
     this.width = width * factor;
@@ -53,7 +54,7 @@ function getTargetBox(target) {
       height: 0 * factor
     });
   } else {
-    return new Box(target.getBoundingClientRect());
+    return new Box(target);
   }
 }
 function getElementBox(el) {
@@ -75,20 +76,14 @@ function getElementBox(el) {
       });
     }
   } else {
-    const rect = el.getBoundingClientRect();
-    return new Box({
-      x: rect.x,
-      y: rect.y,
-      width: el.clientWidth,
-      height: el.clientHeight
-    });
+    return new Box(el);
   }
 }
 
 // Utilities
 /** @see https://stackoverflow.com/a/57876601/2074736 */
 function nullifyTransforms(el) {
-  const rect = new Box(el.getBoundingClientRect());
+  const rect = new Box(el);
   const style = getComputedStyle(el);
   const tx = style.transform;
   if (tx) {
@@ -418,7 +413,11 @@ const makeLocationStrategyProps = propsFactory({
     default: 'auto'
   },
   offset: [Number, String, Array],
-  stickToTarget: Boolean
+  stickToTarget: Boolean,
+  viewportMargin: {
+    type: [Number, String],
+    default: 12
+  }
 }, 'VOverlay-location-strategies');
 function useLocationStrategies(props, data) {
   const contentStyles = ref({});
@@ -605,7 +604,7 @@ function connectedLocationStrategy(data, props, contentStyles) {
 
     const contentBox = getIntrinsicSize(data.contentEl.value, data.isRtl.value);
     const scrollParents = getScrollParents(data.contentEl.value);
-    const viewportMargin = 12;
+    const viewportMargin = Number(props.viewportMargin);
     if (!scrollParents.length) {
       scrollParents.push(document.documentElement);
       if (!(data.contentEl.value.style.top && data.contentEl.value.style.left)) {
@@ -625,10 +624,17 @@ function connectedLocationStrategy(data, props, contentStyles) {
       }
       return scrollBox;
     }, undefined);
-    viewport.x += viewportMargin;
-    viewport.y += viewportMargin;
-    viewport.width -= viewportMargin * 2;
-    viewport.height -= viewportMargin * 2;
+    if (props.stickToTarget) {
+      viewport.x += Math.min(viewportMargin, targetBox.x);
+      viewport.y += Math.min(viewportMargin, targetBox.y);
+      viewport.width = Math.max(viewport.width - viewportMargin * 2, targetBox.x + targetBox.width - viewportMargin);
+      viewport.height = Math.max(viewport.height - viewportMargin * 2, targetBox.y + targetBox.height - viewportMargin);
+    } else {
+      viewport.x += viewportMargin;
+      viewport.y += viewportMargin;
+      viewport.width -= viewportMargin * 2;
+      viewport.height -= viewportMargin * 2;
+    }
     let placement = {
       anchor: preferredAnchor.value,
       origin: preferredOrigin.value
@@ -739,19 +745,19 @@ function connectedLocationStrategy(data, props, contentStyles) {
 
       // shift
       if (overflows.x.before) {
-        if (!props.stickToTarget) x += overflows.x.before;
+        x += overflows.x.before;
         contentBox.x += overflows.x.before;
       }
       if (overflows.x.after) {
-        if (!props.stickToTarget) x -= overflows.x.after;
+        x -= overflows.x.after;
         contentBox.x -= overflows.x.after;
       }
       if (overflows.y.before) {
-        if (!props.stickToTarget) y += overflows.y.before;
+        y += overflows.y.before;
         contentBox.y += overflows.y.before;
       }
       if (overflows.y.after) {
-        if (!props.stickToTarget) y -= overflows.y.after;
+        y -= overflows.y.after;
         contentBox.y -= overflows.y.after;
       }
 
@@ -760,9 +766,9 @@ function connectedLocationStrategy(data, props, contentStyles) {
         const overflows = getOverflow(contentBox, viewport);
         available.x = viewport.width - overflows.x.before - overflows.x.after;
         available.y = viewport.height - overflows.y.before - overflows.y.after;
-        if (!props.stickToTarget) x += overflows.x.before;
+        x += overflows.x.before;
         contentBox.x += overflows.x.before;
-        if (!props.stickToTarget) y += overflows.y.before;
+        y += overflows.y.before;
         contentBox.y += overflows.y.before;
       }
       break;
@@ -985,11 +991,12 @@ const makeDelayProps = propsFactory({
 }, 'delay');
 function useDelay(props, cb) {
   let clearDelay = () => {};
-  function runDelay(isOpening) {
+  function runDelay(isOpening, options) {
     clearDelay?.();
-    const delay = Number(isOpening ? props.openDelay : props.closeDelay);
+    const delay = isOpening ? props.openDelay : props.closeDelay;
+    const normalizedDelay = Math.max(options?.minDelay ?? 0, Number(delay ?? 0));
     return new Promise(resolve => {
-      clearDelay = defer(delay, () => {
+      clearDelay = defer(normalizedDelay, () => {
         cb?.(isOpening);
         resolve(isOpening);
       });
@@ -998,8 +1005,8 @@ function useDelay(props, cb) {
   function runOpenDelay() {
     return runDelay(true);
   }
-  function runCloseDelay() {
-    return runDelay(false);
+  function runCloseDelay(options) {
+    return runDelay(false, options);
   }
   return {
     clearDelay,
@@ -1063,7 +1070,6 @@ function useActivator(props, _ref) {
       isActive.value = !isActive.value;
     },
     onMouseenter: e => {
-      if (e.sourceCapabilities?.firesTouchEvents) return;
       isHovered = true;
       activatorEl.value = e.currentTarget || e.target;
       runOpenDelay();
@@ -1082,7 +1088,9 @@ function useActivator(props, _ref) {
     onBlur: e => {
       isFocused = false;
       e.stopPropagation();
-      runCloseDelay();
+      runCloseDelay({
+        minDelay: 1
+      });
     }
   };
   const activatorEvents = computed(() => {
@@ -1113,13 +1121,16 @@ function useActivator(props, _ref) {
       };
     }
     if (openOnFocus.value) {
-      events.onFocusin = () => {
+      events.onFocusin = e => {
+        if (!e.target.matches(':focus-visible')) return;
         isFocused = true;
         runOpenDelay();
       };
       events.onFocusout = () => {
         isFocused = false;
-        runCloseDelay();
+        runCloseDelay({
+          minDelay: 1
+        });
       };
     }
     if (props.closeOnContentClick) {
@@ -1274,6 +1285,148 @@ function getTarget(selector, vm) {
   return target;
 }
 
+// Utilities
+// Types
+// Composables
+const makeFocusTrapProps = propsFactory({
+  retainFocus: Boolean,
+  captureFocus: Boolean,
+  /** @deprecated */
+  disableInitialFocus: Boolean
+}, 'focusTrap');
+const registry = new Map();
+let subscribers = 0;
+function onKeydown(e) {
+  const activeElement = document.activeElement;
+  if (e.key !== 'Tab' || !activeElement) return;
+  const parentTraps = Array.from(registry.values()).filter(_ref => {
+    let {
+      isActive,
+      contentEl
+    } = _ref;
+    return isActive.value && contentEl.value?.contains(activeElement);
+  }).map(x => x.contentEl.value);
+  let closestTrap;
+  let currentParent = activeElement.parentElement;
+  while (currentParent) {
+    if (parentTraps.includes(currentParent)) {
+      closestTrap = currentParent;
+      break;
+    }
+    currentParent = currentParent.parentElement;
+  }
+  if (!closestTrap) return;
+  const focusable = focusableChildren(closestTrap)
+  // excluding VListItems with tabindex="-2"
+  .filter(x => x.tabIndex >= 0);
+  if (!focusable.length) return;
+  const active = document.activeElement;
+  if (focusable.length === 1 && focusable[0].classList.contains('v-list') && focusable[0].contains(active)) {
+    e.preventDefault();
+    return;
+  }
+  const firstElement = focusable[0];
+  const lastElement = focusable[focusable.length - 1];
+  if (e.shiftKey && (active === firstElement || firstElement.classList.contains('v-list') && firstElement.contains(active))) {
+    e.preventDefault();
+    lastElement.focus();
+  }
+  if (!e.shiftKey && (active === lastElement || lastElement.classList.contains('v-list') && lastElement.contains(active))) {
+    e.preventDefault();
+    firstElement.focus();
+  }
+}
+function useFocusTrap(props, _ref2) {
+  let {
+    isActive,
+    localTop,
+    contentEl
+  } = _ref2;
+  const trapId = Symbol('trap');
+  let focusTrapSuppressed = false;
+  let focusTrapSuppressionTimeout = -1;
+  async function onPointerdown() {
+    focusTrapSuppressed = true;
+    focusTrapSuppressionTimeout = window.setTimeout(() => {
+      focusTrapSuppressed = false;
+    }, 100);
+  }
+  async function captureOnFocus(e) {
+    const before = e.relatedTarget;
+    const after = e.target;
+    document.removeEventListener('pointerdown', onPointerdown);
+    document.removeEventListener('keydown', captureOnKeydown);
+    await nextTick();
+    if (isActive.value && !focusTrapSuppressed && before !== after && contentEl.value &&
+    // We're the menu without open submenus or overlays
+    toValue(localTop) &&
+    // It isn't the document or the container body
+    ![document, contentEl.value].includes(after) &&
+    // It isn't inside the container body
+    !contentEl.value.contains(after)) {
+      const focusable = focusableChildren(contentEl.value);
+      focusable[0]?.focus();
+    }
+  }
+  function captureOnKeydown(e) {
+    if (e.key !== 'Tab') return;
+    document.removeEventListener('keydown', captureOnKeydown);
+    if (isActive.value && contentEl.value && e.target && !contentEl.value.contains(e.target)) {
+      const allFocusableElements = focusableChildren(document.documentElement);
+      if (e.shiftKey && e.target === allFocusableElements.at(0) || !e.shiftKey && e.target === allFocusableElements.at(-1)) {
+        const focusable = focusableChildren(contentEl.value);
+        if (focusable.length > 0) {
+          e.preventDefault();
+          focusable[0].focus();
+        }
+      }
+    }
+  }
+  const shouldCapture = toRef(() => isActive.value && props.captureFocus && !props.disableInitialFocus);
+  if (IN_BROWSER) {
+    watch(() => props.retainFocus, val => {
+      if (val) {
+        registry.set(trapId, {
+          isActive,
+          contentEl
+        });
+      } else {
+        registry.delete(trapId);
+      }
+    }, {
+      immediate: true
+    });
+    watch(shouldCapture, val => {
+      if (val) {
+        document.addEventListener('pointerdown', onPointerdown);
+        document.addEventListener('focusin', captureOnFocus, {
+          once: true
+        });
+        document.addEventListener('keydown', captureOnKeydown);
+      } else {
+        document.removeEventListener('pointerdown', onPointerdown);
+        document.removeEventListener('focusin', captureOnFocus);
+        document.removeEventListener('keydown', captureOnKeydown);
+      }
+    }, {
+      immediate: true
+    });
+    if (subscribers++ < 1) {
+      document.addEventListener('keydown', onKeydown);
+    }
+  }
+  onScopeDispose(() => {
+    registry.delete(trapId);
+    clearTimeout(focusTrapSuppressionTimeout);
+    document.removeEventListener('pointerdown', onPointerdown);
+    document.removeEventListener('focusin', captureOnFocus);
+    document.removeEventListener('keydown', captureOnKeydown);
+    if (--subscribers < 1) {
+      document.removeEventListener('keydown', onKeydown);
+    }
+  });
+}
+
 // Composables
 function useHydration() {
   if (!IN_BROWSER) return shallowRef(false);
@@ -1432,6 +1585,7 @@ const makeVOverlayProps = propsFactory({
   ...makeLazyProps(),
   ...makeLocationStrategyProps(),
   ...makeScrollStrategyProps(),
+  ...makeFocusTrapProps(),
   ...makeThemeProps(),
   ...makeTransitionProps()
 }, 'VOverlay');
@@ -1443,7 +1597,7 @@ const VOverlay = genericComponent()({
   inheritAttrs: false,
   props: {
     _disableGlobalStack: Boolean,
-    ...makeVOverlayProps()
+    ...omit(makeVOverlayProps(), ['disableInitialFocus'])
   },
   emits: {
     'click:outside': e => true,
@@ -1543,10 +1697,14 @@ const VOverlay = genericComponent()({
       if (!props.persistent) isActive.value = false;else animateClick();
     }
     function closeConditional(e) {
-      return isActive.value && globalTop.value && (
+      return isActive.value && localTop.value && (
       // If using scrim, only close if clicking on it rather than anything opened on top
       !props.scrim || e.target === scrimEl.value || e instanceof MouseEvent && e.shadowTarget === scrimEl.value);
     }
+    useFocusTrap(props, {
+      isActive,
+      localTop,
+      contentEl});
     IN_BROWSER && watch(isActive, val => {
       if (val) {
         window.addEventListener('keydown', onKeydown);
@@ -1672,6 +1830,7 @@ const VOverlay = genericComponent()({
       target,
       animateClick,
       contentEl,
+      rootEl: root,
       globalTop,
       localTop,
       updateLocation