@maas/vue-equipment 1.1.0 → 1.2.0

package/dist/nuxt/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@maas/vue-equipment/nuxt",
   "configKey": "vueEquipment",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "unknown"

package/dist/nuxt/module.mjs

@@ -122,7 +122,7 @@ const functions$1 = [
 	{
 		name: "MagicTray",
 		"package": "plugins",
-		lastUpdated: 1792675743000,
+		lastUpdated: 1793032883000,
 		docs: "https://vue.equipment/plugins/MagicTray",
 		description: "MagicTray is a flexible"
 	},

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

@@ -2,7 +2,7 @@ import { easeOutQuad } from "@maas/vue-equipment/utils";
 const defaultOptions = {
   loop: false,
   threshold: {
-    lock: 10
+    lock: 8
   },
   animation: {
     snap: {

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/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/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
 };

package/dist/plugins/MagicTray/src/components/MagicTrayContent.d.vue.ts

@@ -1,9 +1,9 @@
 import type { MagicTraySide } from '../types/index.js';
-declare var __VLS_9: {}, __VLS_11: {}, __VLS_25: "handle-top" | "handle-right" | "handle-bottom" | "handle-left" | "handle", __VLS_26: {
+declare var __VLS_9: {}, __VLS_11: {}, __VLS_24: "handle-top" | "handle-right" | "handle-bottom" | "handle-left" | "handle", __VLS_25: {
     side: MagicTraySide;
 };
 type __VLS_Slots = {} & {
-    [K in NonNullable<typeof __VLS_25>]?: (props: typeof __VLS_26) => any;
+    [K in NonNullable<typeof __VLS_24>]?: (props: typeof __VLS_25) => any;
 } & {
     background?: (props: typeof __VLS_9) => any;
 } & {

package/dist/plugins/MagicTray/src/components/MagicTrayContent.vue

@@ -40,7 +40,6 @@
           :style="handleStyle(side)"
           @pointerdown="guardedPointerdown(side, $event)"
           @touchstart="guardedTouchstart(side, $event)"
-          @click.capture="onHandleClick"
         >
           <template
             v-if="slots[`handle-${side}`] || slots.handle"
@@ -62,6 +61,7 @@ import { computed, inject, useSlots, useTemplateRef } from "vue";
 import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
 import { useTrayState } from "../composables/private/useTrayState";
 import { useTrayDrag } from "../composables/private/useTrayDrag";
+import { useTrayGesture } from "../composables/private/useTrayGesture";
 import { useTrayMagnetism } from "../composables/private/useTrayMagnetism";
 import { useTrayProgress } from "../composables/private/useTrayProgress";
 import MagicTrayHandle from "./MagicTrayHandle.vue";
@@ -94,18 +94,15 @@ const handleRefs = {
 const disabled = computed(() => state.options.disabled);
 const inset = computed(() => state.options.inset);
 const slots = useSlots();
-const {
-  draggableSides,
-  clipPath,
-  handleStyle,
-  hasDragged,
-  onHandlePointerdown,
-  onHandleTouchstart,
-  onHandleClick
-} = useTrayDrag({
+const { draggableSides, clipPath, handleStyle } = useTrayDrag({
   id: instanceId,
   elRef
 });
+const { hasDragged, onPointerdown, onTouchstart } = useTrayGesture({
+  id: instanceId,
+  state,
+  preventEdgeNavigation: () => state.options.preventEdgeNavigation
+});
 useTrayMagnetism({ id: instanceId, elRef, handleRefs, state });
 useTrayProgress({ id: instanceId, state });
 const visibleHandles = computed(() => {
@@ -120,12 +117,12 @@ const visibleHandles = computed(() => {
 });
 function guardedPointerdown(side, event) {
   if (!disabled.value) {
-    onHandlePointerdown(side, event);
+    onPointerdown(side, event);
   }
 }
 function guardedTouchstart(side, event) {
   if (!disabled.value) {
-    onHandleTouchstart(side, event);
+    onTouchstart(side, event);
   }
 }
 </script>
@@ -200,10 +197,6 @@ function guardedTouchstart(side, event) {
   pointer-events: var(--magic-tray-content-pointer-events, auto);
 }
 
-.magic-tray-content[data-inset='true'] .magic-tray-content__slot {
-  padding: var(--magic-tray-drag-overshoot-outer);
-}
-
 .magic-tray-content__inner[data-drag-top='true'] {
   padding-top: var(--magic-tray-drag-overshoot-outer);
 }
@@ -242,4 +235,12 @@ dialog.magic-tray-content__inner {
 .magic-tray-content[data-dragging='true'] .magic-tray-handle {
   cursor: var(--magic-tray-handle-cursor-dragging, grabbing);
 }
+
+.magic-tray-content[data-dragging='true'] .magic-tray-handle * {
+  -webkit-user-drag: none;
+}
+
+.magic-tray-content[data-dragged='true'] .magic-tray-handle * {
+  pointer-events: none;
+}
 </style>

package/dist/plugins/MagicTray/src/components/MagicTrayContent.vue.d.ts

@@ -1,9 +1,9 @@
 import type { MagicTraySide } from '../types/index.js';
-declare var __VLS_9: {}, __VLS_11: {}, __VLS_25: "handle-top" | "handle-right" | "handle-bottom" | "handle-left" | "handle", __VLS_26: {
+declare var __VLS_9: {}, __VLS_11: {}, __VLS_24: "handle-top" | "handle-right" | "handle-bottom" | "handle-left" | "handle", __VLS_25: {
     side: MagicTraySide;
 };
 type __VLS_Slots = {} & {
-    [K in NonNullable<typeof __VLS_25>]?: (props: typeof __VLS_26) => any;
+    [K in NonNullable<typeof __VLS_24>]?: (props: typeof __VLS_25) => any;
 } & {
     background?: (props: typeof __VLS_9) => any;
 } & {

package/dist/plugins/MagicTray/src/components/MagicTrayTrigger.d.vue.ts

@@ -0,0 +1,25 @@
+import type { MaybeRef } from 'vue';
+import type { MagicTraySide } from '../types/index.js';
+interface MagicTrayTriggerProps {
+    id?: MaybeRef<string>;
+    side: MagicTraySide;
+    disabled?: boolean;
+    preventEdgeNavigation?: boolean;
+    asChild?: boolean;
+}
+declare var __VLS_11: {
+    dragging: boolean;
+    disabled: any;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicTrayTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicTrayTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/plugins/MagicTray/src/components/MagicTrayTrigger.vue

@@ -0,0 +1,90 @@
+<template>
+  <vue-primitive
+    class="magic-tray-trigger"
+    :as-child="asChild"
+    :data-id="`${mappedId}-trigger`"
+    :data-side="side"
+    :data-dragging="active"
+    :data-dragged="hasDragged"
+    :data-disabled="mappedDisabled"
+    @pointerdown="guardedPointerdown"
+    @touchstart="guardedTouchstart"
+  >
+    <slot :dragging="active" :disabled="mappedDisabled" />
+  </vue-primitive>
+</template>
+
+<script setup>
+import { computed, inject, toValue } from "vue";
+import { VuePrimitive } from "@maas/vue-primitive";
+import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
+import { useTrayState } from "../composables/private/useTrayState";
+import { useTrayGesture } from "../composables/private/useTrayGesture";
+import { MagicTrayInstanceId } from "../symbols";
+const { id, side, disabled, preventEdgeNavigation, asChild } = defineProps({
+  id: { type: null, required: false },
+  side: { type: String, required: true },
+  disabled: { type: Boolean, required: false },
+  preventEdgeNavigation: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false }
+});
+const injectedInstanceId = inject(MagicTrayInstanceId, void 0);
+const mappedInstanceId = computed(() => id ?? injectedInstanceId);
+const magicError = useMagicError({
+  prefix: "MagicTray",
+  source: "MagicTrayTrigger"
+});
+magicError.assert(mappedInstanceId.value, {
+  message: "MagicTrayTrigger must be nested inside MagicTrayProvider or an id must be provided",
+  errorCode: "missing_instance_id"
+});
+const mappedId = computed(() => toValue(mappedInstanceId.value ?? ""));
+const { initializeState } = useTrayState(mappedId);
+const state = initializeState();
+const { active, hasDragged, onPointerdown, onTouchstart } = useTrayGesture({
+  id: mappedId,
+  state,
+  selectionLock: "drag",
+  preventEdgeNavigation: () => preventEdgeNavigation ?? state.options.preventEdgeNavigation
+});
+const mappedDisabled = computed(() => disabled || state.options.disabled);
+function isEditable(target) {
+  if (!(target instanceof Element)) {
+    return false;
+  }
+  return target.closest("input, textarea, select") !== null || target instanceof HTMLElement && target.isContentEditable;
+}
+function canDrag(event) {
+  return !mappedDisabled.value && !isEditable(event.target);
+}
+function guardedPointerdown(event) {
+  if (canDrag(event)) {
+    onPointerdown(side, event);
+  }
+}
+function guardedTouchstart(event) {
+  if (canDrag(event)) {
+    onTouchstart(side, event);
+  }
+}
+</script>
+
+<style>
+.magic-tray-trigger[data-disabled='false'][data-side='left'],
+.magic-tray-trigger[data-disabled='false'][data-side='right'] {
+  touch-action: var(--magic-tray-trigger-touch-action, pan-y);
+}
+
+.magic-tray-trigger[data-disabled='false'][data-side='top'],
+.magic-tray-trigger[data-disabled='false'][data-side='bottom'] {
+  touch-action: var(--magic-tray-trigger-touch-action, pan-x);
+}
+
+.magic-tray-trigger[data-dragging='true'] * {
+  -webkit-user-drag: none;
+}
+
+.magic-tray-trigger[data-dragged='true'] * {
+  pointer-events: none;
+}
+</style>

package/dist/plugins/MagicTray/src/components/MagicTrayTrigger.vue.d.ts

@@ -0,0 +1,25 @@
+import type { MaybeRef } from 'vue';
+import type { MagicTraySide } from '../types/index.js';
+interface MagicTrayTriggerProps {
+    id?: MaybeRef<string>;
+    side: MagicTraySide;
+    disabled?: boolean;
+    preventEdgeNavigation?: boolean;
+    asChild?: boolean;
+}
+declare var __VLS_11: {
+    dragging: boolean;
+    disabled: any;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicTrayTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicTrayTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/plugins/MagicTray/src/composables/private/useTrayDrag.d.ts

@@ -32,10 +32,6 @@ export declare function useTrayDrag(args: UseTrayDragArgs): {
         '--magic-tray-handle-magnetic': string;
         left?: undefined;
     };
-    hasDragged: import("vue").ComputedRef<boolean>;
     dimension: (side: MagicTraySide) => number;
-    onHandlePointerdown: (side: MagicTraySide, e: PointerEvent) => void;
-    onHandleTouchstart: (side: MagicTraySide, e: TouchEvent) => void;
-    onHandleClick: (e: MouseEvent) => void;
 };
 export {};