@maas/vue-equipment 0.16.3 → 0.16.5

package/dist/nuxt/module.json

@@ -1,5 +1,5 @@
 {
   "name": "@maas/vue-equipment/nuxt",
   "configKey": "vueEquipment",
-  "version": "0.16.2"
+  "version": "0.16.4"
 }

package/dist/plugins/MagicDrawer/src/components/MagicDrawer.vue

@@ -142,6 +142,7 @@ const {
 
 const { onPointerdown, dragging, style } = useDrawerDrag({
   id: props.id,
+  isActive,
   elRef,
   wrapperRef,
   position,
@@ -289,5 +290,5 @@ onBeforeUnmount(() => {
 </script>
 
 <style>
-:root{--magic-drawer-height:75svh;--magic-drawer-z-index:999;--magic-drawer-justify-content:center;--magic-drawer-align-items:flex-end;--magic-drawer-backdrop-color:rgba(0,0,0,.5);--magic-drawer-backdrop-filter:unset;--magic-drawer-content-overflow-y:auto;--magic-drawer-handle-wrapper-height:2rem;--magic-drawer-handle-width:3rem;--magic-drawer-handle-height:0.375rem;--magic-drawer-handle-color:#d4d4d8;--magic-drawer-handle-border-radius:0.25rem;--magic-drawer-enter-animation:slide-btt-in 300ms ease;--magic-drawer-leave-animation:slide-btt-out 300ms ease;--magic-drawer-drag-overshoot:4rem;--magic-drawer-drag-overshoot-x:0;--magic-drawer-drag-overshoot-y:0}.magic-drawer{align-items:var(--magic-drawer-align-items);background:transparent;border:none;color:inherit;display:flex;height:100%;inset:0;justify-content:var(--magic-drawer-justify-content);padding:0;pointer-events:none;position:fixed;width:100%;z-index:var(--magic-drawer-z-index)}.magic-drawer.-bottom{--magic-drawer-drag-overshoot-y:var(--magic-drawer-drag-overshoot)}.magic-drawer.-top{--magic-drawer-enter-animation:slide-ttb-in 300ms ease;--magic-drawer-leave-animation:slide-ttb-out 300ms ease;--magic-drawer-align-items:flex-start;--magic-drawer-drag-overshoot-y:calc(var(--magic-drawer-drag-overshoot)*-1)}.magic-drawer.-right{--magic-drawer-enter-animation:slide-rtl-in 300ms ease;--magic-drawer-leave-animation:slide-rtl-out 300ms ease;--magic-drawer-align-items:center;--magic-drawer-justify-content:flex-end;--magic-drawer-drag-overshoot-x:var(--magic-drawer-drag-overshoot)}.magic-drawer.-left{--magic-drawer-enter-animation:slide-ltr-in 300ms ease;--magic-drawer-leave-animation:slide-ltr-out 300ms ease;--magic-drawer-align-items:center;--magic-drawer-justify-content:flex-start;--magic-drawer-drag-overshoot-x:calc(var(--magic-drawer-drag-overshoot)*-1)}.magic-drawer__wrapper{height:calc(var(--magic-drawer-height) + var(--magic-drawer-drag-overshoot));pointer-events:none;transform:translate(var(--magic-drawer-drag-overshoot-x),var(--magic-drawer-drag-overshoot-y));width:100%}.magic-drawer__content{height:100%;max-height:100%;position:relative;width:100%}.magic-drawer__drag{-webkit-overflow-scrolling:touch;align-items:var(--magic-drawer-align-items);cursor:grab;display:flex;height:100%;justify-content:var(--magic-drawer-justify-content);overflow-y:var(--magic-drawer-content-overflow-y);pointer-events:auto;position:relative;scroll-behavior:smooth;width:100%}.magic-drawer.-dragging .magic-drawer__content{cursor:grabbing}.magic-drawer__backdrop{-webkit-backdrop-filter:var(--magic-drawer-backdrop-filter);backdrop-filter:var(--magic-drawer-backdrop-filter);background-color:var(--magic-drawer-backdrop-color);bottom:0;height:100%;left:0;pointer-events:auto;position:fixed;right:0;top:0;width:100%;z-index:-1}.magic-drawer--content-enter-active{animation:var(--magic-drawer-enter-animation)}.magic-drawer--content-leave-active{animation:var(--magic-drawer-leave-animation)}.magic-drawer--backdrop-enter-active{animation:fade-in .3s ease}.magic-drawer--backdrop-leave-active{animation:fade-out .3s ease}
+:root{--magic-drawer-height:75svh;--magic-drawer-z-index:999;--magic-drawer-justify-content:center;--magic-drawer-align-items:flex-end;--magic-drawer-backdrop-color:rgba(0,0,0,.5);--magic-drawer-backdrop-filter:unset;--magic-drawer-content-overflow-y:auto;--magic-drawer-handle-wrapper-height:2rem;--magic-drawer-handle-width:3rem;--magic-drawer-handle-height:0.375rem;--magic-drawer-handle-color:#d4d4d8;--magic-drawer-handle-border-radius:0.25rem;--magic-drawer-enter-animation:slide-btt-in 300ms ease;--magic-drawer-leave-animation:slide-btt-out 300ms ease;--magic-drawer-drag-overshoot:4rem;--magic-drawer-drag-overshoot-x:0;--magic-drawer-drag-overshoot-y:0}.magic-drawer{align-items:var(--magic-drawer-align-items);background:transparent;border:none;color:inherit;display:flex;height:100%;inset:0;justify-content:var(--magic-drawer-justify-content);padding:0;pointer-events:none;position:fixed;width:100%;z-index:var(--magic-drawer-z-index)}.magic-drawer.-bottom{--magic-drawer-drag-overshoot-y:var(--magic-drawer-drag-overshoot)}.magic-drawer.-top{--magic-drawer-enter-animation:slide-ttb-in 300ms ease;--magic-drawer-leave-animation:slide-ttb-out 300ms ease;--magic-drawer-align-items:flex-start;--magic-drawer-drag-overshoot-y:calc(var(--magic-drawer-drag-overshoot)*-1)}.magic-drawer.-right{--magic-drawer-enter-animation:slide-rtl-in 300ms ease;--magic-drawer-leave-animation:slide-rtl-out 300ms ease;--magic-drawer-align-items:center;--magic-drawer-justify-content:flex-end;--magic-drawer-drag-overshoot-x:var(--magic-drawer-drag-overshoot)}.magic-drawer.-left{--magic-drawer-enter-animation:slide-ltr-in 300ms ease;--magic-drawer-leave-animation:slide-ltr-out 300ms ease;--magic-drawer-align-items:center;--magic-drawer-justify-content:flex-start;--magic-drawer-drag-overshoot-x:calc(var(--magic-drawer-drag-overshoot)*-1)}.magic-drawer__wrapper{height:calc(var(--magic-drawer-height) + var(--magic-drawer-drag-overshoot));pointer-events:none;transform:translate(var(--magic-drawer-drag-overshoot-x),var(--magic-drawer-drag-overshoot-y));width:100%}.magic-drawer__content{height:100%;max-height:100%;position:relative;width:100%}.magic-drawer__drag{-webkit-overflow-scrolling:touch;align-items:var(--magic-drawer-align-items);cursor:grab;display:flex;height:100%;justify-content:var(--magic-drawer-justify-content);overflow-y:var(--magic-drawer-content-overflow-y);pointer-events:auto;position:relative;scroll-behavior:smooth;width:100%}.magic-drawer.-dragging .magic-drawer__drag{cursor:grabbing}.magic-drawer__backdrop{-webkit-backdrop-filter:var(--magic-drawer-backdrop-filter);backdrop-filter:var(--magic-drawer-backdrop-filter);background-color:var(--magic-drawer-backdrop-color);bottom:0;height:100%;left:0;pointer-events:auto;position:fixed;right:0;top:0;width:100%;z-index:-1}.magic-drawer--content-enter-active{animation:var(--magic-drawer-enter-animation)}.magic-drawer--content-leave-active{animation:var(--magic-drawer-leave-animation)}.magic-drawer--backdrop-enter-active{animation:fade-in .3s ease}.magic-drawer--backdrop-leave-active{animation:fade-out .3s ease}
 </style>

package/dist/plugins/MagicDrawer/src/composables/private/useDrawerDrag.d.ts

@@ -2,6 +2,7 @@ import { type MaybeRef } from 'vue';
 import { type DefaultOptions } from '../../utils/defaultOptions.js';
 type UseDrawerDragArgs = {
     id: MaybeRef<string>;
+    isActive: MaybeRef<boolean>;
     elRef: MaybeRef<HTMLDivElement | undefined>;
     wrapperRef: MaybeRef<HTMLDivElement | undefined>;
     position: MaybeRef<DefaultOptions['position']>;

package/dist/plugins/MagicDrawer/src/composables/private/useDrawerDrag.mjs

@@ -7,13 +7,18 @@ import {
   toValue,
   nextTick
 } from "vue";
-import { useEventListener, unrefElement } from "@vueuse/core";
-import { interpolate } from "@maas/vue-equipment/utils";
+import {
+  useEventListener,
+  unrefElement,
+  useResizeObserver,
+  useThrottleFn
+} from "@vueuse/core";
 import { useDrawerEmitter } from "../useDrawerEmitter.mjs";
 import { useDrawerSnap } from "./useDrawerSnap.mjs";
 export function useDrawerDrag(args) {
   const {
     id,
+    isActive,
     elRef,
     wrapperRef,
     snapPoints,
@@ -24,21 +29,6 @@ export function useDrawerDrag(args) {
     canClose,
     close
   } = args;
-  const elRect = ref(void 0);
-  const wrapperRect = ref(void 0);
-  const {
-    findClosestSnapPoint,
-    mapSnapPoint,
-    snapPointsMap,
-    drawerHeight,
-    drawerWidth
-  } = useDrawerSnap({
-    wrapperRect,
-    snapPoints,
-    canClose,
-    position,
-    overshoot
-  });
   const dragStart = ref(void 0);
   const dragging = ref(false);
   const shouldClose = ref(false);
@@ -47,16 +37,36 @@ export function useDrawerDrag(args) {
   let cancelPointermove = void 0;
   const originX = ref(0);
   const originY = ref(0);
-  const snappedY = ref(0);
-  const snappedX = ref(0);
   const directionY = ref("absolute");
   const directionX = ref("absolute");
   const hasSnapPoints = computed(() => toValue(snapPoints).length > 1);
+  const elRect = ref(void 0);
+  const wrapperRect = ref(void 0);
   const draggedX = ref(0);
   const draggedY = ref(0);
   const style = computed(
     () => `transform: translate(${draggedX.value}px, ${draggedY.value}px)`
   );
+  const {
+    snappedY,
+    snappedX,
+    activeSnapPoint,
+    snapTo,
+    snapPointsMap,
+    interpolateDragged,
+    findClosestSnapPoint,
+    drawerHeight,
+    drawerWidth
+  } = useDrawerSnap({
+    id,
+    wrapperRect,
+    snapPoints,
+    canClose,
+    position,
+    overshoot,
+    draggedY,
+    draggedX
+  });
   async function getSizes() {
     elRect.value = unrefElement(elRef)?.getBoundingClientRect();
     wrapperRect.value = unrefElement(wrapperRef)?.getBoundingClientRect();
@@ -228,31 +238,6 @@ export function useDrawerDrag(args) {
         break;
     }
   }
-  async function setInitial() {
-    await nextTick();
-    switch (position) {
-      case "top":
-      case "bottom":
-        const mappedSnapPointY = mapSnapPoint(toValue(snapPoint));
-        if (!mappedSnapPointY)
-          return;
-        draggedY.value = await findClosestSnapPoint({
-          draggedX,
-          draggedY: mappedSnapPointY
-        }) || 0;
-        break;
-      case "left":
-      case "right":
-        const mappedSnapPointX = mapSnapPoint(toValue(snapPoint));
-        if (!mappedSnapPointX)
-          return;
-        draggedX.value = await findClosestSnapPoint({
-          draggedX: mappedSnapPointX,
-          draggedY
-        }) || 0;
-        break;
-    }
-  }
   function resetStateAndListeners() {
     dragging.value = false;
     shouldClose.value = false;
@@ -267,53 +252,20 @@ export function useDrawerDrag(args) {
   function resetSnapped() {
     snappedX.value = 0;
     snappedY.value = 0;
+    activeSnapPoint.value = void 0;
   }
   function emitterCallback(event, payload) {
     if (event === "afterLeave" && payload === toValue(id)) {
       resetDragged();
       resetSnapped();
     }
-  }
-  async function interpolateDragged(target) {
-    const snapPoint2 = snapPointsMap.value[target];
-    useDrawerEmitter().emit("beforeSnap", { id: toValue(id), snapPoint: snapPoint2 });
-    switch (position) {
-      case "bottom":
-      case "top":
-        snappedY.value = target;
-        interpolate({
-          from: draggedY.value,
-          to: target,
-          duration: 300,
-          callback: (value) => {
-            draggedY.value = value;
-            if (draggedY.value === target) {
-              useDrawerEmitter().emit("beforeSnap", {
-                id: toValue(id),
-                snapPoint: snapPoint2
-              });
-            }
-          }
-        });
-        break;
-      case "right":
-      case "left":
-        snappedX.value = target;
-        interpolate({
-          from: draggedX.value,
-          to: target,
-          duration: 300,
-          callback: (value) => {
-            draggedX.value = value;
-            if (draggedX.value === target) {
-              useDrawerEmitter().emit("beforeSnap", {
-                id: toValue(id),
-                snapPoint: snapPoint2
-              });
-            }
-          }
-        });
-        break;
+    if (event === "snapTo" && typeof payload === "object" && payload.id === toValue(id)) {
+      if (!toValue(isActive)) {
+        console.warn("Cannot snap to point when drawer is not open");
+        return;
+      } else {
+        snapTo({ snapPoint: payload.snapPoint, interpolate: true });
+      }
     }
   }
   function onPointerup(e) {
@@ -321,6 +273,17 @@ export function useDrawerDrag(args) {
       close();
     } else if (interpolateTo.value || interpolateTo.value === 0) {
       interpolateDragged(interpolateTo.value);
+      activeSnapPoint.value = snapPointsMap.value[interpolateTo.value];
+      switch (position) {
+        case "bottom":
+        case "top":
+          snappedY.value = interpolateTo.value;
+          break;
+        case "right":
+        case "left":
+          snappedX.value = interpolateTo.value;
+          break;
+      }
     } else {
       switch (position) {
         case "bottom":
@@ -364,12 +327,21 @@ export function useDrawerDrag(args) {
     useDrawerEmitter().on("*", emitterCallback);
   });
   watch(
-    () => [unrefElement(elRef), unrefElement(wrapperRef)],
+    () => [unrefElement(wrapperRef), unrefElement(wrapperRef)],
     async () => {
       await getSizes();
-      setInitial();
+      snapTo({ snapPoint, interpolate: false });
     }
   );
+  useResizeObserver(elRef, async () => {
+    useThrottleFn(async () => {
+      await getSizes();
+      if (activeSnapPoint.value) {
+        await snapTo({ snapPoint: activeSnapPoint.value, interpolate: false });
+        snapPointsMap.trigger();
+      }
+    }, 100)();
+  });
   onBeforeUnmount(() => {
     useDrawerEmitter().off("*", emitterCallback);
   });

package/dist/plugins/MagicDrawer/src/composables/private/useDrawerSnap.d.ts

@@ -1,23 +0,0 @@
-import { type MaybeRef } from 'vue';
-import { type DefaultOptions } from '../../utils/defaultOptions.js';
-import { type SnapPoint } from '../../types.js';
-type UseDrawerSnapArgs = {
-    wrapperRect: MaybeRef<DOMRect | undefined>;
-    position: MaybeRef<DefaultOptions['position']>;
-    snapPoints: MaybeRef<DefaultOptions['snapPoints']>;
-    canClose: MaybeRef<DefaultOptions['canClose']>;
-    overshoot: MaybeRef<number>;
-};
-type FindClosestSnapPointArgs = {
-    draggedY: MaybeRef<number>;
-    draggedX: MaybeRef<number>;
-    direction?: 'below' | 'above' | 'absolute';
-};
-export declare function useDrawerSnap(args: UseDrawerSnapArgs): {
-    findClosestSnapPoint: (args: FindClosestSnapPointArgs) => Promise<number | undefined>;
-    mapSnapPoint: (snapPoint: SnapPoint) => number | undefined;
-    snapPointsMap: import("vue").ComputedRef<Record<number, SnapPoint>>;
-    drawerHeight: import("vue").ComputedRef<number>;
-    drawerWidth: import("vue").ComputedRef<number>;
-};
-export {};

package/dist/plugins/MagicDrawer/src/composables/private/useDrawerSnap.mjs

@@ -1,28 +1,50 @@
-import { computed, toValue } from "vue";
-import { mapValue } from "@maas/vue-equipment/utils";
+import { ref, computed, toValue, nextTick } from "vue";
+import { computedWithControl } from "@vueuse/core";
+import { mapValue, interpolate } from "@maas/vue-equipment/utils";
+import { useDrawerEmitter } from "../useDrawerEmitter.mjs";
 export function useDrawerSnap(args) {
-  const { snapPoints, position, wrapperRect, overshoot, canClose } = args;
-  const mappedSnapPoints = computed(() => {
-    const extended = toValue(canClose) ? [...toValue(snapPoints), 0] : toValue(snapPoints);
-    const mapped = extended.map((snapPoint) => {
-      return mapSnapPoint(snapPoint);
-    });
-    const filtered = mapped.filter(
-      (snapPoint) => !!snapPoint || snapPoint === 0
-    ).sort((a, b) => a - b);
-    return filtered;
-  });
-  const snapPointsMap = computed(() => {
-    const extended = toValue(canClose) ? [...toValue(snapPoints), 0] : toValue(snapPoints);
-    const mapped = extended.reduce((acc, current) => {
-      const key = mapSnapPoint(current);
-      if (key || key === 0) {
-        acc[key] = current;
-      }
-      return acc;
-    }, {});
-    return mapped;
-  });
+  const {
+    id,
+    snapPoints,
+    position,
+    wrapperRect,
+    overshoot,
+    draggedY,
+    draggedX,
+    canClose
+  } = args;
+  const mappedSnapPoints = computedWithControl(
+    () => toValue(wrapperRect),
+    () => {
+      const extended = toValue(canClose) ? [...toValue(snapPoints), 0] : toValue(snapPoints);
+      const mapped = extended.map((snapPoint) => {
+        return mapSnapPoint(snapPoint);
+      });
+      const filtered = mapped.filter(
+        (snapPoint) => !!snapPoint || snapPoint === 0
+      ).sort((a, b) => a - b);
+      return filtered;
+    }
+  );
+  const snapPointsMap = computedWithControl(
+    () => {
+      return { ...toValue(snapPoints) };
+    },
+    () => {
+      const extended = toValue(canClose) ? [...toValue(snapPoints), 0] : toValue(snapPoints);
+      const mapped = extended.reduce((acc, current) => {
+        const key = mapSnapPoint(current);
+        if (key || key === 0) {
+          acc[key] = current;
+        }
+        return acc;
+      }, {});
+      return mapped;
+    }
+  );
+  const snappedY = ref(0);
+  const snappedX = ref(0);
+  const activeSnapPoint = ref(void 0);
   const drawerHeight = computed(() => {
     if (toValue(wrapperRect) === void 0) {
       return 0;
@@ -122,14 +144,95 @@ export function useDrawerSnap(args) {
       }
     }
   }
+  async function snapTo(args2) {
+    const { snapPoint, interpolate: interpolate2 } = args2;
+    await nextTick();
+    switch (position) {
+      case "top":
+      case "bottom":
+        const mappedSnapPointY = mapSnapPoint(toValue(snapPoint));
+        if (!mappedSnapPointY)
+          return;
+        const closestY = await findClosestSnapPoint({
+          draggedX,
+          draggedY: mappedSnapPointY
+        }) || 0;
+        if (interpolate2) {
+          await interpolateDragged(closestY);
+        } else {
+          draggedY.value = closestY;
+        }
+        snappedY.value = closestY;
+        activeSnapPoint.value = toValue(snapPoint);
+        break;
+      case "left":
+      case "right":
+        const mappedSnapPointX = mapSnapPoint(toValue(snapPoint));
+        if (!mappedSnapPointX)
+          return;
+        const closestX = await findClosestSnapPoint({
+          draggedX: mappedSnapPointX,
+          draggedY
+        }) || 0;
+        if (interpolate2) {
+          await interpolateDragged(closestX);
+        } else {
+          draggedX.value = closestX;
+          snappedX.value = closestX;
+        }
+        snappedX.value = closestX;
+        activeSnapPoint.value = toValue(snapPoint);
+        break;
+    }
+  }
+  async function interpolateDragged(target) {
+    const snapPoint = snapPointsMap.value[target];
+    useDrawerEmitter().emit("beforeSnap", { id: toValue(id), snapPoint });
+    switch (position) {
+      case "bottom":
+      case "top":
+        interpolate({
+          from: draggedY.value,
+          to: target,
+          duration: 300,
+          callback: (value) => {
+            draggedY.value = value;
+            if (draggedY.value === target) {
+              useDrawerEmitter().emit("afterSnap", {
+                id: toValue(id),
+                snapPoint
+              });
+            }
+          }
+        });
+        break;
+      case "right":
+      case "left":
+        interpolate({
+          from: draggedX.value,
+          to: target,
+          duration: 300,
+          callback: (value) => {
+            draggedX.value = value;
+            if (draggedX.value === target) {
+              useDrawerEmitter().emit("afterSnap", {
+                id: toValue(id),
+                snapPoint
+              });
+            }
+          }
+        });
+        break;
+    }
+  }
   async function findClosestSnapPoint(args2) {
-    const { draggedY, draggedX, direction = "absolute" } = args2;
+    const { draggedY: draggedY2, draggedX: draggedX2, direction = "absolute" } = args2;
     let closest = 0;
     switch (position) {
       case "bottom":
       case "top":
         closest = findClosestNumber({
-          number: toValue(draggedY),
+          number: toValue(draggedY2),
           numbers: mappedSnapPoints.value,
           direction
         });
@@ -137,7 +240,7 @@ export function useDrawerSnap(args) {
       case "right":
       case "left":
         closest = findClosestNumber({
-          number: toValue(draggedX),
+          number: toValue(draggedX2),
           numbers: mappedSnapPoints.value,
           direction
         });
@@ -146,8 +249,12 @@ export function useDrawerSnap(args) {
     return closest;
   }
   return {
+    snappedY,
+    snappedX,
+    activeSnapPoint,
+    snapTo,
     findClosestSnapPoint,
-    mapSnapPoint,
+    interpolateDragged,
     snapPointsMap,
     drawerHeight,
     drawerWidth

package/dist/plugins/MagicDrawer/src/composables/useDrawerApi.d.ts

@@ -1,5 +1,5 @@
 import { type MaybeRef } from 'vue';
-import type { DrawerOptions } from '../types/index.js';
+import type { DrawerOptions, SnapPoint } from '../types/index.js';
 import type { MaybeElementRef } from '@vueuse/core';
 export type useDrawerApiOptions = Pick<DrawerOptions, 'scrollLock'> & {
     focusTarget: MaybeElementRef;
@@ -9,6 +9,7 @@ export declare function useDrawerApi(id?: MaybeRef<string>, options?: useDrawerA
     isActive: import("vue").ComputedRef<boolean>;
     open: () => void;
     close: () => void;
+    snapTo: (snapPoint: SnapPoint) => void;
     trapFocus: () => void;
     releaseFocus: () => void;
     lockScroll: () => void;

package/dist/plugins/MagicDrawer/src/composables/useDrawerApi.mjs

@@ -4,6 +4,7 @@ import { defu } from "defu";
 import { useScrollLock } from "@vueuse/core";
 import { useFocusTrap } from "@vueuse/integrations/useFocusTrap";
 import { useDrawerStore } from "./private/useDrawerStore.mjs";
+import { useDrawerEmitter } from "./useDrawerEmitter.mjs";
 const defaultOptions = {
   focusTarget: void 0,
   scrollLock: true
@@ -22,6 +23,9 @@ export function useDrawerApi(id, options) {
   function close() {
     removeInstance(mappedId.value);
   }
+  function snapTo(snapPoint) {
+    useDrawerEmitter().emit("snapTo", { id: mappedId.value, snapPoint });
+  }
   function trapFocus() {
     if (focusTrap) {
       focusTrap.activate();
@@ -65,6 +69,7 @@ export function useDrawerApi(id, options) {
     isActive,
     open,
     close,
+    snapTo,
     trapFocus,
     releaseFocus,
     lockScroll,

package/dist/plugins/MagicDrawer/src/types/index.d.ts

@@ -38,6 +38,10 @@ export type DrawerEvents = {
         id: string;
         snapPoint: SnapPoint;
     };
+    snapTo: {
+        id: string;
+        snapPoint: SnapPoint;
+    };
     afterSnap: {
         id: string;
         snapPoint: SnapPoint;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@maas/vue-equipment",
   "description": "A magic collection of Vue composables, plugins, components and directives",
-  "version": "0.16.3",
+  "version": "0.16.5",
   "author": "Robin Scholz <https://github.com/robinscholz>, Christoph Jeworutzki <https://github.com/ChristophJeworutzki>",
   "devDependencies": {
     "@antfu/ni": "^0.21.12",