@maas/vue-equipment 1.1.0 → 1.3.0

package/dist/plugins/MagicDotMatrix/src/utils/presets/fill.mjs

@@ -0,0 +1,10 @@
+export function createFill({ cols, rows }) {
+  const total = cols * rows;
+  return [
+    ...Array.from(
+      { length: total },
+      (_, index) => Array.from({ length: index + 1 }, (__, dot) => dot)
+    ),
+    []
+  ];
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/focus.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createFocus(grid: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/focus.mjs

@@ -0,0 +1,5 @@
+import { getRings } from "../sequence/getRings.mjs";
+export function createFocus(grid) {
+  const rings = [...getRings(grid)].reverse();
+  return [...rings, ...rings.slice(0, -1).reverse(), []];
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/index.d.ts

@@ -0,0 +1,12 @@
+export { createBounce } from './bounce.js';
+export { createCheckerboard } from './checkerboard.js';
+export { createComet } from './comet.js';
+export { createDrift } from './drift.js';
+export { createEqualizer } from './equalizer.js';
+export { createFill } from './fill.js';
+export { createFocus } from './focus.js';
+export { createOrbit } from './orbit.js';
+export { createPulse } from './pulse.js';
+export { createRipple } from './ripple.js';
+export { createScan } from './scan.js';
+export { createSpiral } from './spiral.js';

package/dist/plugins/MagicDotMatrix/src/utils/presets/index.mjs

@@ -0,0 +1,12 @@
+export { createBounce } from "./bounce.mjs";
+export { createCheckerboard } from "./checkerboard.mjs";
+export { createComet } from "./comet.mjs";
+export { createDrift } from "./drift.mjs";
+export { createEqualizer } from "./equalizer.mjs";
+export { createFill } from "./fill.mjs";
+export { createFocus } from "./focus.mjs";
+export { createOrbit } from "./orbit.mjs";
+export { createPulse } from "./pulse.mjs";
+export { createRipple } from "./ripple.mjs";
+export { createScan } from "./scan.mjs";
+export { createSpiral } from "./spiral.mjs";

package/dist/plugins/MagicDotMatrix/src/utils/presets/orbit.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createOrbit({ cols, rows }: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/orbit.mjs

@@ -0,0 +1,8 @@
+import { ringPath } from "../sequence/ringPath.mjs";
+export function createOrbit({ cols, rows }) {
+  const path = ringPath({ cols, rows });
+  if (path.length === 0) {
+    return [[]];
+  }
+  return path.map((_, index) => [path[index]]);
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/pulse.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createPulse(grid: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/pulse.mjs

@@ -0,0 +1,7 @@
+import { getRings } from "../sequence/getRings.mjs";
+export function createPulse(grid) {
+  const rings = getRings(grid);
+  const expand = rings.map((_, index) => rings.slice(0, index + 1).flat());
+  const contract = rings.map((_, index) => rings.slice(0, rings.length - index - 1).flat()).slice(1);
+  return [...expand, ...contract, []];
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/ripple.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createRipple(grid: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/ripple.mjs

@@ -0,0 +1,5 @@
+import { getRings } from "../sequence/getRings.mjs";
+export function createRipple(grid) {
+  const rings = getRings(grid);
+  return [...rings, ...rings.slice(0, -1).reverse(), []];
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/scan.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createScan({ cols, rows }: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/scan.mjs

@@ -0,0 +1,6 @@
+export function createScan({ cols, rows }) {
+  return Array.from(
+    { length: rows },
+    (_, row) => Array.from({ length: cols }, (__, col) => row * cols + col)
+  );
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/spiral.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createSpiral(grid: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/spiral.mjs

@@ -0,0 +1,34 @@
+function spiralOrder({ cols, rows }) {
+  const result = [];
+  let top = 0;
+  let bottom = rows - 1;
+  let left = 0;
+  let right = cols - 1;
+  while (top <= bottom && left <= right) {
+    for (let col = left; col <= right; col++) {
+      result.push(top * cols + col);
+    }
+    top++;
+    for (let row = top; row <= bottom; row++) {
+      result.push(row * cols + right);
+    }
+    right--;
+    if (top <= bottom) {
+      for (let col = right; col >= left; col--) {
+        result.push(bottom * cols + col);
+      }
+      bottom--;
+    }
+    if (left <= right) {
+      for (let row = bottom; row >= top; row--) {
+        result.push(row * cols + left);
+      }
+      left++;
+    }
+  }
+  return result;
+}
+export function createSpiral(grid) {
+  const order = spiralOrder(grid);
+  return [...order.map((_, index) => order.slice(0, index + 1)), []];
+}

package/dist/plugins/MagicDotMatrix/src/utils/sequence/equalizerFrame.d.ts

@@ -0,0 +1,7 @@
+import type { DotMatrixFrame } from '../../types/index.js';
+export type EqualizerFrameArgs = {
+    heights: Array<number>;
+    cols: number;
+    rows: number;
+};
+export declare function equalizerFrame({ heights, cols, rows, }: EqualizerFrameArgs): DotMatrixFrame;

package/dist/plugins/MagicDotMatrix/src/utils/sequence/equalizerFrame.mjs

@@ -0,0 +1,12 @@
+export function equalizerFrame({
+  heights,
+  cols,
+  rows
+}) {
+  return heights.flatMap(
+    (height, col) => Array.from(
+      { length: Math.max(0, Math.min(height, rows)) },
+      (_, index) => (rows - 1 - index) * cols + col
+    )
+  );
+}

package/dist/plugins/MagicDotMatrix/src/utils/sequence/getRings.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixFrame, DotMatrixGrid } from '../../types/index.js';
+export declare function getRings({ cols, rows }: DotMatrixGrid): Array<DotMatrixFrame>;

package/dist/plugins/MagicDotMatrix/src/utils/sequence/getRings.mjs

@@ -0,0 +1,24 @@
+import { toIndex } from "./toIndex.mjs";
+export function getRings({ cols, rows }) {
+  const centerCol = (cols - 1) / 2;
+  const centerRow = (rows - 1) / 2;
+  const maxRing = Math.max(
+    Math.ceil(Math.max(centerCol, cols - 1 - centerCol)),
+    Math.ceil(Math.max(centerRow, rows - 1 - centerRow))
+  );
+  return Array.from({ length: maxRing + 1 }, (_, ring) => {
+    const indices = [];
+    for (let row = 0; row < rows; row++) {
+      for (let col = 0; col < cols; col++) {
+        const distance = Math.max(
+          Math.abs(col - centerCol),
+          Math.abs(row - centerRow)
+        );
+        if (Math.floor(distance + 0.5) === ring) {
+          indices.push(toIndex({ col, row, cols }));
+        }
+      }
+    }
+    return indices;
+  }).filter((frame) => frame.length > 0);
+}

package/dist/plugins/MagicDotMatrix/src/utils/sequence/ringPath.d.ts

@@ -0,0 +1,7 @@
+import type { DotMatrixFrame } from '../../types/index.js';
+export type RingPathArgs = {
+    cols: number;
+    rows: number;
+    inset?: number;
+};
+export declare function ringPath({ cols, rows, inset, }: RingPathArgs): DotMatrixFrame;

package/dist/plugins/MagicDotMatrix/src/utils/sequence/ringPath.mjs

@@ -0,0 +1,35 @@
+import { toIndex } from "./toIndex.mjs";
+export function ringPath({
+  cols,
+  rows,
+  inset = 0
+}) {
+  const left = inset;
+  const top = inset;
+  const right = cols - 1 - inset;
+  const bottom = rows - 1 - inset;
+  if (left > right || top > bottom) {
+    return [];
+  }
+  if (left === right && top === bottom) {
+    return [toIndex({ col: left, row: top, cols })];
+  }
+  const path = [];
+  for (let col = left; col <= right; col++) {
+    path.push(toIndex({ col, row: top, cols }));
+  }
+  for (let row = top + 1; row <= bottom; row++) {
+    path.push(toIndex({ col: right, row, cols }));
+  }
+  if (bottom > top) {
+    for (let col = right - 1; col >= left; col--) {
+      path.push(toIndex({ col, row: bottom, cols }));
+    }
+  }
+  if (right > left) {
+    for (let row = bottom - 1; row > top; row--) {
+      path.push(toIndex({ col: left, row, cols }));
+    }
+  }
+  return path;
+}

package/dist/plugins/MagicDotMatrix/src/utils/sequence/toIndex.d.ts

@@ -0,0 +1,6 @@
+export type ToIndexArgs = {
+    col: number;
+    row: number;
+    cols: number;
+};
+export declare function toIndex({ col, row, cols }: ToIndexArgs): number;

package/dist/plugins/MagicDotMatrix/src/utils/sequence/toIndex.mjs

@@ -0,0 +1,3 @@
+export function toIndex({ col, row, cols }) {
+  return row * cols + col;
+}

package/dist/plugins/MagicDotMatrix/src/utils/sequence/withTrail.d.ts

@@ -0,0 +1,6 @@
+import type { DotMatrixFrame, DotMatrixSequence } from '../../types/index.js';
+export type WithTrailArgs = {
+    path: DotMatrixFrame;
+    length?: number;
+};
+export declare function withTrail({ path, length, }: WithTrailArgs): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/sequence/withTrail.mjs

@@ -0,0 +1,17 @@
+export function withTrail({
+  path,
+  length = 3
+}) {
+  if (path.length === 0) {
+    return [[]];
+  }
+  const trail = Math.max(1, Math.min(length, path.length));
+  return path.map((_, index) => [
+    ...new Set(
+      Array.from(
+        { length: trail },
+        (__, offset) => path[(index + offset) % path.length]
+      )
+    )
+  ]);
+}

package/dist/plugins/MagicDraggable/src/utils/defaultOptions.mjs

@@ -4,7 +4,7 @@ const defaultOptions = {
   scrollLock: { padding: true },
   snapPoints: ["top-left", "top-right", "bottom-left", "bottom-right"],
   threshold: {
-    lock: 0,
+    lock: 8,
     distance: 128,
     momentum: 1.5,
     idle: 250

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

@@ -367,6 +367,10 @@ dialog.magic-drawer-content__drag::backdrop {
   user-select: none;
 }
 
+.magic-drawer-content[data-dragging='true'] .magic-drawer-content__drag * {
+  -webkit-user-drag: none;
+}
+
 .magic-drawer-content[data-wheeling='true'] .magic-drawer-content__drag {
   cursor: auto;
 }

package/dist/plugins/MagicDrawer/src/components/MagicDrawerTrigger.d.vue.ts

@@ -6,7 +6,7 @@ interface MagicDrawerTriggerProps {
 }
 declare var __VLS_10: {
     active: any;
-    disabled: boolean;
+    disabled: any;
 };
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_10) => any;

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

@@ -18,7 +18,11 @@ import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
 import { useMagicDrawer } from "../composables/useMagicDrawer";
 import { useDrawerState } from "../composables/private/useDrawerState";
 import { MagicDrawerInstanceId } from "../symbols";
-const { id, disabled, asChild } = defineProps({
+const {
+  id,
+  disabled = void 0,
+  asChild
+} = defineProps({
   id: { type: null, required: false },
   disabled: { type: Boolean, required: false },
   asChild: { type: Boolean, required: false }

package/dist/plugins/MagicDrawer/src/components/MagicDrawerTrigger.vue.d.ts

@@ -6,7 +6,7 @@ interface MagicDrawerTriggerProps {
 }
 declare var __VLS_10: {
     active: any;
-    disabled: boolean;
+    disabled: any;
 };
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_10) => any;

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

@@ -456,8 +456,6 @@ export function useDrawerDrag(args) {
       return;
     }
     checkDirection({ x: firstTouch.clientX, y: firstTouch.clientY });
-    shouldClose.value = false;
-    checkDirection({ x: firstTouch.clientX, y: firstTouch.clientY });
     if (!scrollLock) {
       const scrollLockTarget = lockScroll(firstTouch.target);
       if (scrollLockTarget) {
@@ -611,6 +609,7 @@ export function useDrawerDrag(args) {
       await getSizes();
       const snapPoint = toValue(initial)?.snapPoint;
       if (!snapPoint) {
+        activeSnapPoint.value = snapPointAt(0);
         return;
       }
       if (isUnknownSnapPoint(snapPoint)) {

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

@@ -14,6 +14,10 @@ import { useDrawerState } from "./useDrawerState.mjs";
 export function useDrawerProgress(args) {
   const { id, drawerRef, elRef, position, overshoot } = args;
   const { initializeState } = useDrawerState(id);
+  const emitter = useMagicEmitter();
+  const state = initializeState();
+  const { draggedX, draggedY, wrapperRect } = toRefs(state);
+  let transitioning = false;
   const drawerRect = useElementBounding(drawerRef);
   const elRect = useElementBounding(elRef);
   const maxX = computed(
@@ -22,27 +26,38 @@ export function useDrawerProgress(args) {
   const maxY = computed(
     () => drawerRect.height.value - elRect.height.value + toValue(overshoot)
   );
-  const state = initializeState();
   const { progress } = toRefs(state);
-  function rafCallback() {
+  function setProgress(x, y) {
+    progress.value = {
+      x: clampValue(x, 0, 1) || 0,
+      y: clampValue(y, 0, 1) || 0
+    };
+  }
+  function calculate() {
+    const rect = wrapperRect.value;
+    if (!rect) {
+      setProgress(0, 0);
+      return;
+    }
+    const extentX = rect.width - toValue(overshoot);
+    const extentY = rect.height - toValue(overshoot);
+    switch (toValue(position)) {
+      case "top":
+      case "bottom":
+        setProgress(0, extentY ? 1 - Math.abs(draggedY.value) / extentY : 0);
+        break;
+      case "left":
+      case "right":
+        setProgress(extentX ? 1 - Math.abs(draggedX.value) / extentX : 0, 0);
+        break;
+    }
+  }
+  function measure() {
     drawerRect.update();
     elRect.update();
-    calculateProgress();
-  }
-  const emitter = useMagicEmitter();
-  const { pause: snapPause, resume: snapResume } = useRafFn(rafCallback, {
-    immediate: false
-  });
-  const { pause: dragPause, resume: dragResume } = useRafFn(rafCallback, {
-    immediate: false
-  });
-  const { pause, resume } = useRafFn(rafCallback, {
-    immediate: false
-  });
-  function calculateProgress() {
     let rawX = 0;
     let rawY = 0;
-    switch (position) {
+    switch (toValue(position)) {
       case "bottom":
         rawY = mapValue(
           elRect.top.value,
@@ -80,81 +95,46 @@ export function useDrawerProgress(args) {
         );
         break;
     }
-    if (Object.is(rawX, -0)) {
-      rawX = 0;
-    }
-    if (Object.is(rawY, -0)) {
-      rawY = 0;
-    }
-    const x = clampValue(rawX, 0, 1);
-    const y = clampValue(rawY, 0, 1);
-    progress.value = { x, y };
+    setProgress(rawX, rawY);
   }
-  watch([() => progress.value.x, () => progress.value.y], ([x, y]) => {
-    emitter.emit("progress", {
-      id: toValue(id),
-      x,
-      y
-    });
-  });
-  function beforeCallback(payload) {
+  const { pause, resume } = useRafFn(measure, { immediate: false });
+  function beforeTransition(payload) {
     if (payload === toValue(id)) {
+      transitioning = true;
       resume();
     }
   }
-  function beforeSnapCallback(payload) {
-    if (payload.id === toValue(id)) {
-      snapResume();
-    }
-  }
-  function beforeDragCallback(payload) {
-    if (payload.id === toValue(id)) {
-      dragResume();
-    }
-  }
-  async function afterCallback(payload) {
+  async function afterTransition(payload) {
     await nextTick();
     if (payload === toValue(id)) {
       pause();
-      await nextTick();
-      rafCallback();
-    }
-  }
-  async function afterSnapCallback(payload) {
-    await nextTick();
-    if (payload.id === toValue(id)) {
-      snapPause();
-      await nextTick();
-      rafCallback();
+      transitioning = false;
+      calculate();
     }
   }
-  async function afterDragCallback(payload) {
-    await nextTick();
-    if (payload.id === toValue(id)) {
-      dragPause();
-      await nextTick();
-      rafCallback();
+  watch([draggedX, draggedY, wrapperRect, () => toValue(overshoot)], () => {
+    if (!transitioning) {
+      calculate();
     }
-  }
+  });
+  watch([() => progress.value.x, () => progress.value.y], ([x, y]) => {
+    emitter.emit("progress", {
+      id: toValue(id),
+      x,
+      y
+    });
+  });
   onMounted(() => {
-    emitter.on("beforeEnter", beforeCallback);
-    emitter.on("afterEnter", afterCallback);
-    emitter.on("beforeDrag", beforeDragCallback);
-    emitter.on("afterDrag", afterDragCallback);
-    emitter.on("beforeSnap", beforeSnapCallback);
-    emitter.on("afterSnap", afterSnapCallback);
-    emitter.on("beforeLeave", beforeCallback);
-    emitter.on("afterLeave", afterCallback);
+    emitter.on("beforeEnter", beforeTransition);
+    emitter.on("afterEnter", afterTransition);
+    emitter.on("beforeLeave", beforeTransition);
+    emitter.on("afterLeave", afterTransition);
   });
   onBeforeUnmount(() => {
-    emitter.off("beforeEnter", beforeCallback);
-    emitter.off("afterEnter", afterCallback);
-    emitter.off("beforeDrag", beforeDragCallback);
-    emitter.off("afterDrag", afterDragCallback);
-    emitter.off("beforeSnap", beforeSnapCallback);
-    emitter.off("afterSnap", afterSnapCallback);
-    emitter.off("beforeLeave", beforeCallback);
-    emitter.off("afterLeave", afterCallback);
+    emitter.off("beforeEnter", beforeTransition);
+    emitter.off("afterEnter", afterTransition);
+    emitter.off("beforeLeave", beforeTransition);
+    emitter.off("afterLeave", afterTransition);
   });
   return { progress };
 }

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

@@ -8,7 +8,6 @@ import {
 } from "@maas/vue-equipment/utils";
 import { useMagicEmitter } from "@maas/vue-equipment/plugins/MagicEmitter";
 import { useDrawerUtils } from "./useDrawerUtils.mjs";
-const SNAP_TOLERANCE = 0.01;
 function isMapped(value) {
   return value !== void 0 && !Number.isNaN(value);
 }
@@ -193,7 +192,7 @@ export function useDrawerSnap(args) {
   function configuredPointAt(offset) {
     return configuredPoints.value.find((snapPoint) => {
       const mapped = mapSnapPoint(snapPoint);
-      return isMapped(mapped) && Math.abs(mapped - offset) < SNAP_TOLERANCE;
+      return mapped === offset;
     });
   }
   function draggedOnAxis() {
@@ -242,9 +241,7 @@ export function useDrawerSnap(args) {
     if (!isMapped(mapped)) {
       return false;
     }
-    return !!rangeAt(mapped) || mappedSnapPoints.value.some(
-      (point) => Math.abs(point - mapped) < SNAP_TOLERANCE
-    );
+    return !!rangeAt(mapped) || mappedSnapPoints.value.includes(mapped);
   }
   function findSnapTarget(offset) {
     const target = snapTargetAt({

package/dist/plugins/MagicDrawer/src/utils/defaultOptions.mjs

@@ -21,7 +21,7 @@ const defaultOptions = {
     backdrop: "magic-drawer-backdrop"
   },
   threshold: {
-    lock: 0,
+    lock: 8,
     distance: 128,
     momentum: 1
   },

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

@@ -1,6 +1,7 @@
 import type { AccordionEvents } from '../../../MagicAccordion/src/types/index.js';
 import type { CarouselEvents } from '../../../MagicCarousel/src/types/index.js';
 import type { CookieEvents } from '../../../MagicCookie/src/types/index.js';
+import type { DotMatrixEvents } from '../../../MagicDotMatrix/src/types/index.js';
 import type { DraggableEvents } from '../../../MagicDraggable/src/types/index.js';
 import type { DrawerEvents } from '../../../MagicDrawer/src/types/index.js';
 import type { ModalEvents } from '../../../MagicModal/src/types/index.js';
@@ -17,6 +18,7 @@ export type MagicEmitterEvents = Merge<[
     AccordionEvents,
     CarouselEvents,
     CookieEvents,
+    DotMatrixEvents,
     DraggableEvents,
     DrawerEvents,
     ModalEvents,

package/dist/plugins/MagicMenu/src/components/MagicMenuTrigger.vue

@@ -29,7 +29,12 @@ import {
   MagicMenuItemId,
   MagicMenuViewId
 } from "../symbols";
-const { instanceId, viewId, disabled, trigger } = defineProps({
+const {
+  instanceId,
+  viewId,
+  disabled = void 0,
+  trigger
+} = defineProps({
   instanceId: { type: String, required: false },
   viewId: { type: String, required: false },
   disabled: { type: Boolean, required: false },
@@ -54,13 +59,18 @@ magicError.assert(mappedViewId.value, {
   message: "MagicMenuTrigger must be nested inside MagicMenuView or a viewId must be provided",
   errorCode: "missing_view_id"
 });
-const { getView, getRelativeViewIndex } = useMenuView(mappedInstanceId.value);
+const { getView, getRelativeViewIndex, getParentView } = useMenuView(
+  mappedInstanceId.value
+);
 const view = getView(mappedViewId.value);
 const viewIndex = getRelativeViewIndex(mappedViewId.value);
 const { initializeState } = useMenuState(mappedInstanceId.value);
 const state = initializeState();
 const { getItem } = useMenuItem(mappedInstanceId.value);
-const item = getItem({ viewId: mappedViewId.value, id: itemId ?? "" });
+const item = getItem({
+  viewId: getParentView(mappedViewId.value)?.id ?? "",
+  id: itemId ?? ""
+});
 const mappedDisabled = computed(() => disabled ?? item?.disabled ?? false);
 const mappedTrigger = computed(() => {
   if (trigger?.length) {

package/dist/plugins/MagicTray/index.d.ts

@@ -2,10 +2,11 @@ import MagicTray from './src/components/MagicTray.vue.js';
 import MagicTrayProvider from './src/components/MagicTrayProvider.vue.js';
 import MagicTrayContent from './src/components/MagicTrayContent.vue.js';
 import MagicTrayHandle from './src/components/MagicTrayHandle.vue.js';
+import MagicTrayTrigger from './src/components/MagicTrayTrigger.vue.js';
 import MagicTrayTransform from './src/components/MagicTrayTransform.vue.js';
 import { useMagicTray } from './src/composables/useMagicTray.js';
 import type { Plugin } from 'vue';
 import type { MagicTrayDragMode, MagicTrayOptions, MagicTraySide, MagicTraySidePayload, MagicTraySnapEntry, MagicTraySnapMode, MagicTraySnapPoint, MagicTraySnapPointPayload, MagicTraySnapRange, MagicTrayTransformAxis, MagicTrayWillSnapToPayload } from './src/types/index.js';
 declare const MagicTrayPlugin: Plugin;
-export { MagicTrayPlugin, MagicTray, MagicTrayProvider, MagicTrayContent, MagicTrayHandle, MagicTrayTransform, useMagicTray, };
+export { MagicTrayPlugin, MagicTray, MagicTrayProvider, MagicTrayContent, MagicTrayHandle, MagicTrayTrigger, MagicTrayTransform, useMagicTray, };
 export type { MagicTrayOptions, MagicTraySide, MagicTraySidePayload, MagicTraySnapMode, MagicTrayDragMode, MagicTraySnapPoint, MagicTraySnapRange, MagicTraySnapEntry, MagicTraySnapPointPayload, MagicTrayWillSnapToPayload, MagicTrayTransformAxis, };

package/dist/plugins/MagicTray/index.mjs

@@ -2,6 +2,7 @@ import MagicTray from "./src/components/MagicTray.vue";
 import MagicTrayProvider from "./src/components/MagicTrayProvider.vue";
 import MagicTrayContent from "./src/components/MagicTrayContent.vue";
 import MagicTrayHandle from "./src/components/MagicTrayHandle.vue";
+import MagicTrayTrigger from "./src/components/MagicTrayTrigger.vue";
 import MagicTrayTransform from "./src/components/MagicTrayTransform.vue";
 import { useMagicTray } from "./src/composables/useMagicTray.mjs";
 const MagicTrayPlugin = {
@@ -10,6 +11,7 @@ const MagicTrayPlugin = {
     app.component("MagicTrayProvider", MagicTrayProvider);
     app.component("MagicTrayContent", MagicTrayContent);
     app.component("MagicTrayHandle", MagicTrayHandle);
+    app.component("MagicTrayTrigger", MagicTrayTrigger);
     app.component("MagicTrayTransform", MagicTrayTransform);
   }
 };
@@ -19,6 +21,7 @@ export {
   MagicTrayProvider,
   MagicTrayContent,
   MagicTrayHandle,
+  MagicTrayTrigger,
   MagicTrayTransform,
   useMagicTray
 };