@eodash/eodash 5.0.0 → 5.2.0

package/dist/client/{PopUp-BfB8s_ki.js → PopUp-CgpvNr3o.js}

@@ -1,12 +1,12 @@
-import { createVNode, Transition, mergeProps, ref, onBeforeUnmount, watch, nextTick, toRef, mergeModels, useModel, createElementBlock, openBlock, withCtx, createBlock, createCommentVNode, resolveDynamicComponent, unref, renderSlot } from 'vue';
-import { g as genericComponent, p as propsFactory, j as useProxiedModel, I as IN_BROWSER, a as useRender, z as focusableChildren, N as VDefaultsProvider, b as provideTheme, B as useBackgroundColor, K as useBorder, H as useDimension, L as useElevation, az as useLocation, aA as usePosition, M as useRounded, f as makeThemeProps, h as makeTagProps, O as makeRoundedProps, aD as makePositionProps, aE as makeLocationProps, P as makeElevationProps, J as makeDimensionProps, i as makeComponentProps, Q as makeBorderProps, aN as useDefineWidgets } from './asWebComponent-CLhcT715.js';
-import { m as makeVOverlayProps, V as VOverlay } from './VOverlay-BzOdRu9h.js';
-import { a as animate, g as getTargetBox, n as nullifyTransforms, c as acceleratedEasing, d as deceleratedEasing, s as standardEasing, b as useScopeId, f as forwardRefs } from './forwardRefs-Bon_Kku1.js';
+import { createVNode, Transition, mergeProps, ref, onBeforeUnmount, watch, nextTick, normalizeStyle, normalizeClass, mergeModels, useModel, createElementBlock, openBlock, withCtx, createBlock, createCommentVNode, resolveDynamicComponent, unref, renderSlot } from 'vue';
+import { g as genericComponent, p as propsFactory, x as useProxiedModel, al as IN_BROWSER, c as useRender, am as focusableChildren, V as VDefaultsProvider, k as provideTheme, f as useBackgroundColor, h as useBorder, b as useDimension, i as useElevation, a7 as useLocation, a8 as usePosition, j as useRounded, q as makeThemeProps, m as makeTagProps, r as makeRoundedProps, ab as makePositionProps, ac as makeLocationProps, s as makeElevationProps, d as makeDimensionProps, e as makeComponentProps, t as makeBorderProps, an as useDefineWidgets } from './asWebComponent-ZyEzWOOf.js';
+import { a as animate, g as getTargetBox, n as nullifyTransforms, b as acceleratedEasing, d as deceleratedEasing, s as standardEasing, u as useScopeId, f as forwardRefs, m as makeVOverlayProps, V as VOverlay } from './forwardRefs-BQclvjMq.js';
 
 // Utilities
 const makeVDialogTransitionProps = propsFactory({
   target: [Object, Array]
 }, 'v-dialog-transition');
+const saved = new WeakMap();
 const VDialogTransition = genericComponent()({
   name: 'VDialogTransition',
   props: makeVDialogTransitionProps(),
@@ -23,13 +23,15 @@ const VDialogTransition = genericComponent()({
         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
-        } = getDimensions(props.target, el);
+        } = dimensions;
+        saved.set(el, dimensions);
         const animation = animate(el, [{
           transform: `translate(${x}px, ${y}px) scale(${sx}, ${sy})`,
           opacity: 0
@@ -58,13 +60,19 @@ const VDialogTransition = genericComponent()({
       },
       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
-        } = getDimensions(props.target, el);
+        } = dimensions;
         const animation = animate(el, [{}, {
           transform: `translate(${x}px, ${y}px) scale(${sx}, ${sy})`,
           opacity: 0
@@ -208,7 +216,7 @@ const VDialog = genericComponent()({
     }
     function onAfterEnter() {
       emit('afterEnter');
-      if (overlay.value?.contentEl && !overlay.value.contentEl.contains(document.activeElement)) {
+      if ((props.scrim || props.retainFocus) && overlay.value?.contentEl && !overlay.value.contentEl.contains(document.activeElement)) {
         overlay.value.contentEl.focus({
           preventScroll: true
         });
@@ -296,7 +304,7 @@ const VSheet = genericComponent()({
     const {
       backgroundColorClasses,
       backgroundColorStyles
-    } = useBackgroundColor(toRef(props, 'color'));
+    } = useBackgroundColor(() => props.color);
     const {
       borderClasses
     } = useBorder(props);
@@ -316,8 +324,8 @@ const VSheet = genericComponent()({
       roundedClasses
     } = useRounded(props);
     useRender(() => createVNode(props.tag, {
-      "class": ['v-sheet', themeClasses.value, backgroundColorClasses.value, borderClasses.value, elevationClasses.value, positionClasses.value, roundedClasses.value, props.class],
-      "style": [backgroundColorStyles.value, dimensionStyles.value, locationStyles.value, props.style]
+      "class": normalizeClass(['v-sheet', themeClasses.value, backgroundColorClasses.value, borderClasses.value, elevationClasses.value, positionClasses.value, roundedClasses.value, props.class]),
+      "style": normalizeStyle([backgroundColorStyles.value, dimensionStyles.value, locationStyles.value, props.style])
     }, slots));
     return {};
   }

package/dist/client/ProcessList-vecpxThi.js

@@ -0,0 +1,198 @@
+import { ref, createVNode, normalizeStyle, normalizeClass, createElementVNode, toRefs, onMounted, createElementBlock, openBlock, createBlock, createCommentVNode, unref, withCtx, Fragment, renderList, toDisplayString, withDirectives, toRef } from 'vue';
+import { mdiUploadBox, mdiDownloadBox, mdiTrashCanOutline } from '@mdi/js';
+import { g as genericComponent, p as propsFactory, k as provideTheme, T as useDensity, c as useRender, q as makeThemeProps, m as makeTagProps, U as makeDensityProps, e as makeComponentProps, o as convertToUnit, _ as _export_sfc, E as useSTAcStore, P as useOnLayersUpdate, G as VBtn } from './asWebComponent-ZyEzWOOf.js';
+import { D as compareIndicator, C as indicator } from './helpers-wXK7Ywio.js';
+import { u as updateJobsStatus, j as getJobStatusUrl, l as loadProcess, k as downloadPreviousResults, m as deleteJob } from './async-B7jIrM53.js';
+import { T as Tooltip } from './index-9KR-G20t.js';
+
+/**
+ * The list of job result from the server
+ * {job_start_datetime: string, job_end_datetime: string,status: string}
+ *  @type {import("vue").Ref<import("./types").AsyncJob[]>}
+ **/
+const jobs = ref([]);
+/**
+ * The list of jobs results from the server for the compare map
+ * @type {import("vue").Ref<import("./types").AsyncJob[]>}
+ */
+const compareJobs = ref([]);
+
+const _style_0 = "div.v-table__wrapper{overflow:hidden!important;height:max-content!important}.processUrl{text-decoration:none;color:var(--v-theme-primary)}";
+
+const makeVTableProps = propsFactory({
+  fixedHeader: Boolean,
+  fixedFooter: Boolean,
+  height: [Number, String],
+  hover: Boolean,
+  striped: {
+    type: String,
+    default: null,
+    validator: v => ['even', 'odd'].includes(v)
+  },
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeTagProps(),
+  ...makeThemeProps()
+}, 'VTable');
+const VTable = genericComponent()({
+  name: 'VTable',
+  props: makeVTableProps(),
+  setup(props, _ref) {
+    let {
+      slots} = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    useRender(() => createVNode(props.tag, {
+      "class": normalizeClass(['v-table', {
+        'v-table--fixed-height': !!props.height,
+        'v-table--fixed-header': props.fixedHeader,
+        'v-table--fixed-footer': props.fixedFooter,
+        'v-table--has-top': !!slots.top,
+        'v-table--has-bottom': !!slots.bottom,
+        'v-table--hover': props.hover,
+        'v-table--striped-even': props.striped === 'even',
+        'v-table--striped-odd': props.striped === 'odd'
+      }, themeClasses.value, densityClasses.value, props.class]),
+      "style": normalizeStyle(props.style)
+    }, {
+      default: () => [slots.top?.(), slots.default ? createElementVNode("div", {
+        "class": "v-table__wrapper",
+        "style": {
+          height: convertToUnit(props.height)
+        }
+      }, [createElementVNode("table", null, [slots.default()])]) : slots.wrapper?.(), slots.bottom?.()]
+    }));
+    return {};
+  }
+});
+
+const _hoisted_1 = ["href"];
+const _hoisted_2 = { style: {"padding":"0px"} };
+const _hoisted_3 = { style: {"padding":"0px"} };
+const _hoisted_4 = { style: {"padding":"0px"} };
+
+const _sfc_main = {
+  __name: 'ProcessList',
+  props: {
+  enableCompare: {
+    type: Boolean,
+    default: false,
+  },
+  mapElement: {
+    /** @type {import("vue").PropType<import("@eox/map").EOxMap | null>} */
+    type: Object,
+    default: () => null,
+  },
+},
+  setup(__props) {
+
+
+const { selectedStac, selectedCompareStac } = toRefs(useSTAcStore());
+const currentJobs = __props.enableCompare ? compareJobs : jobs;
+const currentIndicator = __props.enableCompare ? compareIndicator : indicator;
+const currentStac = __props.enableCompare ? selectedCompareStac : selectedStac;
+
+onMounted(() => {
+  updateJobsStatus(currentJobs, currentIndicator.value);
+});
+
+useOnLayersUpdate(() => updateJobsStatus(currentJobs, currentIndicator.value));
+
+return (_ctx, _cache) => {
+                                                     
+                                                         
+                                                         
+
+  return (openBlock(), createElementBlock("div", null, [
+    (unref(currentJobs).length)
+      ? (openBlock(), createBlock(VTable, {
+          key: 0,
+          density: "compact",
+          style: {"background-color":"transparent"}
+        }, {
+          default: withCtx(() => [
+            _cache[0] || (_cache[0] = createElementVNode("thead", null, [
+              createElementVNode("tr", null, [
+                createElementVNode("th", { class: "text-left" }, "Executed on"),
+                createElementVNode("th", { class: "text-left" }, "Status"),
+                createElementVNode("th", { class: "text-left" }),
+                createElementVNode("th", { class: "text-left" }),
+                createElementVNode("th", { class: "text-left" })
+              ])
+            ], -1 /* CACHED */)),
+            createElementVNode("tbody", null, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(currentJobs), (item) => {
+                return (openBlock(), createElementBlock("tr", {
+                  key: item.jobID
+                }, [
+                  createElementVNode("td", null, [
+                    createElementVNode("a", {
+                      class: "processUrl",
+                      target: "_blank",
+                      href: unref(getJobStatusUrl)(item.jobID, unref(currentIndicator))
+                    }, toDisplayString(new Date(item.job_start_datetime).toISOString().slice(0, 16)), 9 /* TEXT, PROPS */, _hoisted_1)
+                  ]),
+                  createElementVNode("td", null, toDisplayString(item.status), 1 /* TEXT */),
+                  createElementVNode("td", _hoisted_2, [
+                    withDirectives(createVNode(VBtn, {
+                      disabled: item.status !== 'successful',
+                      color: "primary",
+                      onClick: $event => (unref(loadProcess)(item, unref(currentStac), __props.mapElement)),
+                      icon: [unref(mdiUploadBox)],
+                      variant: "text"
+                    }, null, 8 /* PROPS */, ["disabled", "onClick", "icon"]), [
+                      [Tooltip, 'Load results to map']
+                    ])
+                  ]),
+                  createElementVNode("td", _hoisted_3, [
+                    withDirectives(createVNode(VBtn, {
+                      disabled: item.status !== 'successful',
+                      color: "primary",
+                      onClick: $event => (unref(downloadPreviousResults)(item, unref(currentStac))),
+                      icon: [unref(mdiDownloadBox)],
+                      variant: "text"
+                    }, null, 8 /* PROPS */, ["disabled", "onClick", "icon"]), [
+                      [Tooltip, 'Download results']
+                    ])
+                  ]),
+                  createElementVNode("td", _hoisted_4, [
+                    withDirectives(createVNode(VBtn, {
+                      color: "#ff5252",
+                      onClick: $event => (
+                unref(deleteJob)(
+                  toRef(() => unref(currentJobs)),
+                  item,
+                  unref(currentIndicator),
+                )
+              ),
+                      icon: [unref(mdiTrashCanOutline)],
+                      variant: "text"
+                    }, null, 8 /* PROPS */, ["onClick", "icon"]), [
+                      [Tooltip, 'Remove job']
+                    ])
+                  ])
+                ]))
+              }), 128 /* KEYED_FRAGMENT */))
+            ])
+          ]),
+          _: 1 /* STABLE */,
+          __: [0]
+        }))
+      : createCommentVNode("v-if", true)
+  ]))
+}
+}
+
+};
+const ProcessList = /*#__PURE__*/_export_sfc(_sfc_main, [['styles',[_style_0]]]);
+
+const ProcessList$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  default: ProcessList
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { ProcessList as P, ProcessList$1 as a, compareJobs as c, jobs as j };

package/dist/client/{VImg-FD1WVphJ.js → VImg-CETuikH2.js}

@@ -1,6 +1,6 @@
-import { createVNode, computed, toRef, shallowRef, ref, watch, onBeforeMount, nextTick, onBeforeUnmount, withDirectives, mergeProps, Fragment, resolveDirective, vShow } from 'vue';
-import { aL as SUPPORTS_INTERSECTION, g as genericComponent, p as propsFactory, H as useDimension, a as useRender, J as makeDimensionProps, i as makeComponentProps, B as useBackgroundColor, M as useRounded, aM as getCurrentInstance, q as convertToUnit, O as makeRoundedProps } from './asWebComponent-CLhcT715.js';
-import { m as makeTransitionProps, M as MaybeTransition } from './transition-C5I57hn6.js';
+import { h, TransitionGroup, Transition, camelize, createElementVNode, normalizeStyle, normalizeClass, computed, shallowRef, ref, watch, onBeforeMount, nextTick, onBeforeUnmount, toRef, withDirectives, createVNode, mergeProps, Fragment, vShow } from 'vue';
+import { aj as SUPPORTS_INTERSECTION, g as genericComponent, p as propsFactory, b as useDimension, c as useRender, d as makeDimensionProps, e as makeComponentProps, f as useBackgroundColor, j as useRounded, ak as getCurrentInstance, o as convertToUnit, r as makeRoundedProps } from './asWebComponent-ZyEzWOOf.js';
+import { m as makeTransitionProps$1, M as MaybeTransition } from './transition-yBii4fu6.js';
 
 // Utilities
 function mounted(el, binding) {
@@ -47,6 +47,201 @@ const Intersect = {
   unmounted
 };
 
+// Utilities
+const makeTransitionProps = propsFactory({
+  disabled: Boolean,
+  group: Boolean,
+  hideOnLeave: Boolean,
+  leaveAbsolute: Boolean,
+  mode: String,
+  origin: String
+}, 'transition');
+function createCssTransition(name, origin, mode) {
+  return genericComponent()({
+    name,
+    props: makeTransitionProps({
+      mode,
+      origin
+    }),
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const functions = {
+        onBeforeEnter(el) {
+          if (props.origin) {
+            el.style.transformOrigin = props.origin;
+          }
+        },
+        onLeave(el) {
+          if (props.leaveAbsolute) {
+            const {
+              offsetTop,
+              offsetLeft,
+              offsetWidth,
+              offsetHeight
+            } = el;
+            el._transitionInitialStyles = {
+              position: el.style.position,
+              top: el.style.top,
+              left: el.style.left,
+              width: el.style.width,
+              height: el.style.height
+            };
+            el.style.position = 'absolute';
+            el.style.top = `${offsetTop}px`;
+            el.style.left = `${offsetLeft}px`;
+            el.style.width = `${offsetWidth}px`;
+            el.style.height = `${offsetHeight}px`;
+          }
+          if (props.hideOnLeave) {
+            el.style.setProperty('display', 'none', 'important');
+          }
+        },
+        onAfterLeave(el) {
+          if (props.leaveAbsolute && el?._transitionInitialStyles) {
+            const {
+              position,
+              top,
+              left,
+              width,
+              height
+            } = el._transitionInitialStyles;
+            delete el._transitionInitialStyles;
+            el.style.position = position || '';
+            el.style.top = top || '';
+            el.style.left = left || '';
+            el.style.width = width || '';
+            el.style.height = height || '';
+          }
+        }
+      };
+      return () => {
+        const tag = props.group ? TransitionGroup : Transition;
+        return h(tag, {
+          name: props.disabled ? '' : name,
+          css: !props.disabled,
+          ...(props.group ? undefined : {
+            mode: props.mode
+          }),
+          ...(props.disabled ? {} : functions)
+        }, slots.default);
+      };
+    }
+  });
+}
+function createJavascriptTransition(name, functions) {
+  let mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'in-out';
+  return genericComponent()({
+    name,
+    props: {
+      mode: {
+        type: String,
+        default: mode
+      },
+      disabled: Boolean,
+      group: Boolean
+    },
+    setup(props, _ref2) {
+      let {
+        slots
+      } = _ref2;
+      const tag = props.group ? TransitionGroup : Transition;
+      return () => {
+        return h(tag, {
+          name: props.disabled ? '' : name,
+          css: !props.disabled,
+          // mode: props.mode, // TODO: vuejs/vue-next#3104
+          ...(props.disabled ? {} : functions)
+        }, slots.default);
+      };
+    }
+  });
+}
+
+// Utilities
+function ExpandTransitionGenerator () {
+  let expandedParentClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  const sizeProperty = x ? 'width' : 'height';
+  const offsetProperty = camelize(`offset-${sizeProperty}`);
+  return {
+    onBeforeEnter(el) {
+      el._parent = el.parentNode;
+      el._initialStyle = {
+        transition: el.style.transition,
+        overflow: el.style.overflow,
+        [sizeProperty]: el.style[sizeProperty]
+      };
+    },
+    onEnter(el) {
+      const initialStyle = el._initialStyle;
+      if (!initialStyle) return;
+      el.style.setProperty('transition', 'none', 'important');
+      // Hide overflow to account for collapsed margins in the calculated height
+      el.style.overflow = 'hidden';
+      const offset = `${el[offsetProperty]}px`;
+      el.style[sizeProperty] = '0';
+
+      el.style.transition = initialStyle.transition;
+      if (expandedParentClass && el._parent) {
+        el._parent.classList.add(expandedParentClass);
+      }
+      requestAnimationFrame(() => {
+        el.style[sizeProperty] = offset;
+      });
+    },
+    onAfterEnter: resetStyles,
+    onEnterCancelled: resetStyles,
+    onLeave(el) {
+      el._initialStyle = {
+        transition: '',
+        overflow: el.style.overflow,
+        [sizeProperty]: el.style[sizeProperty]
+      };
+      el.style.overflow = 'hidden';
+      el.style[sizeProperty] = `${el[offsetProperty]}px`;
+
+      requestAnimationFrame(() => el.style[sizeProperty] = '0');
+    },
+    onAfterLeave,
+    onLeaveCancelled: onAfterLeave
+  };
+  function onAfterLeave(el) {
+    if (expandedParentClass && el._parent) {
+      el._parent.classList.remove(expandedParentClass);
+    }
+    resetStyles(el);
+  }
+  function resetStyles(el) {
+    if (!el._initialStyle) return;
+    const size = el._initialStyle[sizeProperty];
+    el.style.overflow = el._initialStyle.overflow;
+    if (size != null) el.style[sizeProperty] = size;
+    delete el._initialStyle;
+  }
+}
+
+createCssTransition('fab-transition', 'center center', 'out-in');
+
+// Generic transitions
+createCssTransition('dialog-bottom-transition');
+createCssTransition('dialog-top-transition');
+createCssTransition('fade-transition');
+createCssTransition('scale-transition');
+createCssTransition('scroll-x-transition');
+createCssTransition('scroll-x-reverse-transition');
+createCssTransition('scroll-y-transition');
+createCssTransition('scroll-y-reverse-transition');
+createCssTransition('slide-x-transition');
+createCssTransition('slide-x-reverse-transition');
+createCssTransition('slide-y-transition');
+createCssTransition('slide-y-reverse-transition');
+
+// Javascript transitions
+const VExpandTransition = createJavascriptTransition('expand-transition', ExpandTransitionGenerator());
+createJavascriptTransition('expand-x-transition', ExpandTransitionGenerator('', true));
+
 function useAspectStyles(props) {
   return {
     aspectStyles: computed(() => {
@@ -77,16 +272,16 @@ const VResponsive = genericComponent()({
     const {
       dimensionStyles
     } = useDimension(props);
-    useRender(() => createVNode("div", {
-      "class": ['v-responsive', {
+    useRender(() => createElementVNode("div", {
+      "class": normalizeClass(['v-responsive', {
         'v-responsive--inline': props.inline
-      }, props.class],
-      "style": [dimensionStyles.value, props.style]
-    }, [createVNode("div", {
+      }, props.class]),
+      "style": normalizeStyle([dimensionStyles.value, props.style])
+    }, [createElementVNode("div", {
       "class": "v-responsive__sizer",
-      "style": aspectStyles.value
-    }, null), slots.additional?.(), slots.default && createVNode("div", {
-      "class": ['v-responsive__content', props.contentClass]
+      "style": normalizeStyle(aspectStyles.value)
+    }, null), slots.additional?.(), slots.default && createElementVNode("div", {
+      "class": normalizeClass(['v-responsive__content', props.contentClass])
     }, [slots.default()])]));
     return {};
   }
@@ -127,12 +322,12 @@ const makeVImgProps = propsFactory({
   ...makeVResponsiveProps(),
   ...makeComponentProps(),
   ...makeRoundedProps(),
-  ...makeTransitionProps()
+  ...makeTransitionProps$1()
 }, 'VImg');
 const VImg = genericComponent()({
   name: 'VImg',
   directives: {
-    intersect: Intersect
+    vIntersect: Intersect
   },
   props: makeVImgProps(),
   emits: {
@@ -148,7 +343,7 @@ const VImg = genericComponent()({
     const {
       backgroundColorClasses,
       backgroundColorStyles
-    } = useBackgroundColor(toRef(props, 'color'));
+    } = useBackgroundColor(() => props.color);
     const {
       roundedClasses
     } = useRounded(props);
@@ -255,14 +450,14 @@ const VImg = genericComponent()({
       };
       poll();
     }
-    const containClasses = computed(() => ({
+    const containClasses = toRef(() => ({
       'v-img__img--cover': props.cover,
       'v-img__img--contain': !props.cover
     }));
     const __image = () => {
       if (!normalisedSrc.value.src || state.value === 'idle') return null;
-      const img = createVNode("img", {
-        "class": ['v-img__img', containClasses.value],
+      const img = createElementVNode("img", {
+        "class": normalizeClass(['v-img__img', containClasses.value]),
         "style": {
           objectPosition: props.position
         },
@@ -282,7 +477,7 @@ const VImg = genericComponent()({
         "transition": props.transition,
         "appear": true
       }, {
-        default: () => [withDirectives(sources ? createVNode("picture", {
+        default: () => [withDirectives(sources ? createElementVNode("picture", {
           "class": "v-img__picture"
         }, [sources, img]) : img, [[vShow, state.value === 'loaded']])]
       });
@@ -290,8 +485,8 @@ const VImg = genericComponent()({
     const __preloadImage = () => createVNode(MaybeTransition, {
       "transition": props.transition
     }, {
-      default: () => [normalisedSrc.value.lazySrc && state.value !== 'loaded' && createVNode("img", {
-        "class": ['v-img__img', 'v-img__img--preload', containClasses.value],
+      default: () => [normalisedSrc.value.lazySrc && state.value !== 'loaded' && createElementVNode("img", {
+        "class": normalizeClass(['v-img__img', 'v-img__img--preload', containClasses.value]),
         "style": {
           objectPosition: props.position
         },
@@ -308,7 +503,7 @@ const VImg = genericComponent()({
         "transition": props.transition,
         "appear": true
       }, {
-        default: () => [(state.value === 'loading' || state.value === 'error' && !slots.error) && createVNode("div", {
+        default: () => [(state.value === 'loading' || state.value === 'error' && !slots.error) && createElementVNode("div", {
           "class": "v-img__placeholder"
         }, [slots.placeholder()])]
       });
@@ -319,14 +514,14 @@ const VImg = genericComponent()({
         "transition": props.transition,
         "appear": true
       }, {
-        default: () => [state.value === 'error' && createVNode("div", {
+        default: () => [state.value === 'error' && createElementVNode("div", {
           "class": "v-img__error"
         }, [slots.error()])]
       });
     };
     const __gradient = () => {
       if (!props.gradient) return null;
-      return createVNode("div", {
+      return createElementVNode("div", {
         "class": "v-img__gradient",
         "style": {
           backgroundImage: `linear-gradient(${props.gradient})`
@@ -362,9 +557,9 @@ const VImg = genericComponent()({
         "aria-label": props.alt,
         "role": props.alt ? 'img' : undefined
       }), {
-        additional: () => createVNode(Fragment, null, [createVNode(__image, null, null), createVNode(__preloadImage, null, null), createVNode(__gradient, null, null), createVNode(__placeholder, null, null), createVNode(__error, null, null)]),
+        additional: () => createElementVNode(Fragment, null, [createVNode(__image, null, null), createVNode(__preloadImage, null, null), createVNode(__gradient, null, null), createVNode(__placeholder, null, null), createVNode(__error, null, null)]),
         default: slots.default
-      }), [[resolveDirective("intersect"), {
+      }), [[Intersect, {
         handler: init,
         options: props.options
       }, null, {
@@ -381,4 +576,4 @@ const VImg = genericComponent()({
   }
 });
 
-export { VImg as V };
+export { VImg as V, VExpandTransition as a };

package/dist/client/{VMain-DJKG4SvM.js → VMain-Ci9DyaGU.js}

@@ -1,6 +1,6 @@
-import { createVNode } from 'vue';
-import { g as genericComponent, p as propsFactory, H as useDimension, G as useLayout, a as useRender, h as makeTagProps, J as makeDimensionProps, i as makeComponentProps } from './asWebComponent-CLhcT715.js';
-import { u as useSsrBoot } from './ssrBoot-BP7SYRyC.js';
+import { createVNode, normalizeStyle, normalizeClass, createElementVNode } from 'vue';
+import { g as genericComponent, p as propsFactory, b as useDimension, a as useLayout, c as useRender, m as makeTagProps, d as makeDimensionProps, e as makeComponentProps } from './asWebComponent-ZyEzWOOf.js';
+import { u as useSsrBoot } from './ssrBoot-Zgc_Ttvi.js';
 
 const makeVMainProps = propsFactory({
   scrollable: Boolean,
@@ -27,12 +27,12 @@ const VMain = genericComponent()({
       ssrBootStyles
     } = useSsrBoot();
     useRender(() => createVNode(props.tag, {
-      "class": ['v-main', {
+      "class": normalizeClass(['v-main', {
         'v-main--scrollable': props.scrollable
-      }, props.class],
-      "style": [mainStyles.value, ssrBootStyles.value, dimensionStyles.value, props.style]
+      }, props.class]),
+      "style": normalizeStyle([mainStyles.value, ssrBootStyles.value, dimensionStyles.value, props.style])
     }, {
-      default: () => [props.scrollable ? createVNode("div", {
+      default: () => [props.scrollable ? createElementVNode("div", {
         "class": "v-main__scroller"
       }, [slots.default?.()]) : slots.default?.()]
     }));