@maas/vue-equipment 0.40.0 → 1.0.0-beta.10

package/dist/plugins/MagicScroll/src/components/MagicScrollProvider.vue

@@ -1,40 +1,40 @@
-<template>
-  <div class="magic-scroll-provider">
-    <slot :scroll-return="scrollReturn" />
-  </div>
-</template>
-
-<script setup lang="ts">
-import { provide, computed } from 'vue'
-import {
-  useScroll,
-  unrefElement,
-  type MaybeComputedElementRef,
-} from '@vueuse/core'
-import { MagicScrollReturn, MagicScrollParent } from '../symbols'
-
-interface MagicScrollProviderProps {
-  active?: Boolean
-  el?: MaybeComputedElementRef<HTMLElement>
-}
-const props = withDefaults(defineProps<MagicScrollProviderProps>(), {
-  active: () => true,
-})
-
-// computed is used to avoid reactivity issues
-const mappedEl = computed(() => {
-  if (props.el) return unrefElement(props.el)
-  if (typeof window === 'undefined') return undefined
-  return window
-})
-
-const mappedParent = computed(() => {
-  if (props.el) return unrefElement(props.el)
-  return undefined
-})
-
-const scrollReturn = useScroll(mappedEl)
-
-provide(MagicScrollReturn, scrollReturn)
-provide(MagicScrollParent, mappedParent)
+<script>
+import { defineComponent as _defineComponent } from "vue";
+import { unref as _unref, renderSlot as _renderSlot, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
+const _hoisted_1 = { class: "magic-scroll-provider" };
+import { provide, computed } from "vue";
+import { useScroll, unrefElement } from "@vueuse/core";
+import { MagicScrollReturn, MagicScrollTarget } from "../symbols";
+export default /* @__PURE__ */ _defineComponent({
+  __name: "MagicScrollProvider",
+  props: {
+    target: { type: null, required: false }
+  },
+  setup(__props) {
+    const mappedTarget = computed(() => {
+      switch (true) {
+        case !!__props.target:
+          return unrefElement(__props.target);
+        case typeof window !== "undefined":
+          return window;
+        default:
+          return void 0;
+      }
+    });
+    const providedTarget = computed(() => {
+      if (__props.target) {
+        return unrefElement(__props.target);
+      }
+      return void 0;
+    });
+    const scrollReturn = useScroll(mappedTarget);
+    provide(MagicScrollReturn, scrollReturn);
+    provide(MagicScrollTarget, providedTarget);
+    return (_ctx, _cache) => {
+      return _openBlock(), _createElementBlock("div", _hoisted_1, [
+        _renderSlot(_ctx.$slots, "default", { scrollReturn: _unref(scrollReturn) })
+      ]);
+    };
+  }
+});
 </script>

package/dist/plugins/MagicScroll/src/components/MagicScrollProvider.vue.d.ts

@@ -1,42 +1,56 @@
-import { type MaybeComputedElementRef } from '@vueuse/core';
+import { type MaybeElementRef } from '@vueuse/core';
 interface MagicScrollProviderProps {
-    active?: Boolean;
-    el?: MaybeComputedElementRef<HTMLElement>;
+    target?: MaybeElementRef<HTMLElement>;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {
-            scrollReturn: {
-                x: import("vue").WritableComputedRef<number>;
-                y: import("vue").WritableComputedRef<number>;
-                isScrolling: import("vue").Ref<boolean>;
-                arrivedState: {
-                    left: boolean;
-                    right: boolean;
-                    top: boolean;
-                    bottom: boolean;
-                };
-                directions: {
-                    left: boolean;
-                    right: boolean;
-                    top: boolean;
-                    bottom: boolean;
-                };
-                measure(): void;
-            };
-        }): any;
+declare const scrollReturn: {
+    x: import("vue").WritableComputedRef<number, number>;
+    y: import("vue").WritableComputedRef<number, number>;
+    isScrolling: import("vue").Ref<boolean, boolean>;
+    arrivedState: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+    directions: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+    measure(): void;
+};
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_1: {
+    scrollReturn: {
+        x: import("vue").WritableComputedRef<number, number>;
+        y: import("vue").WritableComputedRef<number, number>;
+        isScrolling: import("vue").Ref<boolean, boolean>;
+        arrivedState: {
+            left: boolean;
+            right: boolean;
+            top: boolean;
+            bottom: boolean;
+        };
+        directions: {
+            left: boolean;
+            right: boolean;
+            top: boolean;
+            bottom: boolean;
+        };
+        measure(): void;
     };
-    refs: {};
-    rootEl: HTMLDivElement;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<MagicScrollProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicScrollProviderProps> & Readonly<{}>, {
-    active: Boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, HTMLDivElement>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    default?: (props: typeof __VLS_1) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<MagicScrollProviderProps, {
+    scrollReturn: typeof scrollReturn;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicScrollProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<MagicScrollProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicScrollProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicScroll/src/components/MagicScrollScene.vue

@@ -1,78 +1,89 @@
-<template>
-  <div ref="elRef" class="magic-scroll-scene">
-    <slot :progress="progress" />
-  </div>
-</template>
-
-<script setup lang="ts">
-import { ref, provide, inject, onMounted, watch, nextTick, readonly } from 'vue'
-import { useIntersectionObserver } from '@vueuse/core'
-import { useScrollApi } from '../composables/private/useScrollApi'
+<script>
+import { defineComponent as _defineComponent } from "vue";
+import { renderSlot as _renderSlot, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
+const _hoisted_1 = {
+  ref: "el",
+  class: "magic-scroll-scene"
+};
 import {
-  MagicScrollParent,
+  shallowRef,
+  provide,
+  inject,
+  watch,
+  nextTick,
+  readonly,
+  useTemplateRef
+} from "vue";
+import { useIntersectionObserver } from "@vueuse/core";
+import { useScrollApi } from "../composables/private/useScrollApi";
+import {
+  MagicScrollTarget,
   MagicScrollProgress,
-  MagicScrollReturn,
-} from '../symbols'
-
-import type { FromTo } from '../types'
-
-interface MagicScrollSceneProps {
-  from?: FromTo
-  to?: FromTo
-}
-
-const props = withDefaults(defineProps<MagicScrollSceneProps>(), {
-  from: 'top-bottom',
-  to: 'bottom-top',
-})
-
-const scrollReturn = inject(MagicScrollReturn, undefined)
-const scrollParent = inject(MagicScrollParent)
-
-const elRef = ref<HTMLElement | undefined>(undefined)
-const progress = ref(0)
-const intersecting = ref()
-
-const { getCalculations, getProgress } = useScrollApi({
-  child: elRef,
-  parent: scrollParent,
-  from: props.from,
-  to: props.to,
-})
-
-async function calculate() {
-  getCalculations()
-  await nextTick()
-  progress.value = getProgress()
-}
-
-watch(
-  () => scrollReturn?.y.value,
-  () => {
-    if (intersecting.value) {
-      calculate()
-    }
-  }
-)
-
-watch(
-  () => scrollReturn?.y.value,
-  () => {
-    calculate()
+  MagicScrollReturn
+} from "../symbols";
+export default /* @__PURE__ */ _defineComponent({
+  __name: "MagicScrollScene",
+  props: {
+    from: { type: String, required: false, default: "top-bottom" },
+    to: { type: String, required: false, default: "bottom-top" }
   },
-  { once: true }
-)
-
-useIntersectionObserver(
-  elRef,
-  ([{ isIntersecting }]) => {
-    intersecting.value = isIntersecting
-    if (isIntersecting) {
-      calculate()
+  setup(__props) {
+    const scrollReturn = inject(MagicScrollReturn, void 0);
+    const scrollTarget = inject(MagicScrollTarget, void 0);
+    if (!scrollTarget) {
+      console.error("MagicScrollScene must be used within a MagicScrollProvider");
     }
-  },
-  { rootMargin: '150% 0px 150% 0px', immediate: true }
-)
-
-provide(MagicScrollProgress, readonly(progress))
+    const progress = shallowRef(0);
+    const intersecting = shallowRef(false);
+    const elRef = useTemplateRef("el");
+    const { getCalculations, getProgress } = useScrollApi({
+      child: elRef,
+      parent: scrollTarget,
+      from: __props.from,
+      to: __props.to
+    });
+    async function calculate() {
+      getCalculations();
+      await nextTick();
+      progress.value = getProgress();
+    }
+    watch(
+      () => scrollReturn?.y.value,
+      () => {
+        if (intersecting.value) {
+          calculate();
+        }
+      }
+    );
+    watch(
+      () => scrollReturn?.y.value,
+      () => {
+        calculate();
+      },
+      { once: true }
+    );
+    useIntersectionObserver(
+      elRef,
+      ([{ isIntersecting }]) => {
+        intersecting.value = isIntersecting;
+        if (isIntersecting) {
+          calculate();
+        }
+      },
+      { rootMargin: "150% 0px 150% 0px", immediate: true }
+    );
+    provide(MagicScrollProgress, readonly(progress));
+    return (_ctx, _cache) => {
+      return _openBlock(), _createElementBlock(
+        "div",
+        _hoisted_1,
+        [
+          _renderSlot(_ctx.$slots, "default", { progress: progress.value })
+        ],
+        512
+        /* NEED_PATCH */
+      );
+    };
+  }
+});
 </script>

package/dist/plugins/MagicScroll/src/components/MagicScrollScene.vue.d.ts

@@ -1,28 +1,23 @@
-import type { FromTo } from '../types';
+import type { ScrollIntersection } from '../types/index.js';
 interface MagicScrollSceneProps {
-    from?: FromTo;
-    to?: FromTo;
+    from?: ScrollIntersection;
+    to?: ScrollIntersection;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {
-            progress: number;
-        }): any;
-    };
-    refs: {
-        elRef: HTMLDivElement;
-    };
-    rootEl: HTMLDivElement;
+declare const progress: import("vue").ShallowRef<number, number>;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_1: {
+    progress: number;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<MagicScrollSceneProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicScrollSceneProps> & Readonly<{}>, {
-    to: FromTo;
-    from: FromTo;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, HTMLDivElement>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    default?: (props: typeof __VLS_1) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<MagicScrollSceneProps, {
+    progress: typeof progress;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicScrollSceneProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<MagicScrollSceneProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicScrollSceneProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicScroll/src/composables/private/useCollisionDetection.d.ts

@@ -0,0 +1,13 @@
+import { type MaybeRef } from 'vue';
+import type { CollisionOffset } from '../../types/index.js';
+type UseCollisionDetectionArgs = {
+    id: string;
+    child: MaybeRef<HTMLElement | null>;
+    parent: MaybeRef<HTMLElement | null | undefined>;
+    scrollY: MaybeRef<number>;
+    offset?: CollisionOffset;
+};
+export declare function useCollisionDetection(args: UseCollisionDetectionArgs): {
+    observe: () => void;
+};
+export {};

package/dist/plugins/MagicScroll/src/composables/private/useCollisionDetection.mjs

@@ -0,0 +1,130 @@
+import { shallowRef, reactive, computed, toValue } from "vue";
+import { useElementBounding } from "@vueuse/core";
+import { useMagicEmitter } from "@maas/vue-equipment/plugins";
+export function useCollisionDetection(args) {
+  const { id, scrollY, child, parent, offset } = args;
+  const alerted = reactive({
+    up: {
+      top: {
+        top: false,
+        bottom: false
+      },
+      bottom: {
+        top: false,
+        bottom: false
+      }
+    },
+    down: {
+      top: {
+        top: false,
+        bottom: false
+      },
+      bottom: {
+        top: false,
+        bottom: false
+      }
+    }
+  });
+  const childBoundingRect = useElementBounding(child);
+  const parentBoundingRect = useElementBounding(parent);
+  const mappedOffset = { top: 0, bottom: 0, ...offset };
+  const lastScrollY = shallowRef(0);
+  const scrollDirection = shallowRef();
+  const oppositeScrollDirection = computed(
+    () => scrollDirection.value === "up" ? "down" : "up"
+  );
+  function observe() {
+    if (!lastScrollY.value) {
+      lastScrollY.value = toValue(scrollY);
+      reset();
+      return;
+    }
+    scrollDirection.value = lastScrollY.value <= toValue(scrollY) ? "down" : "up";
+    lastScrollY.value = toValue(scrollY);
+    if (scrollDirection.value) {
+      observeItem({
+        childEdge: "top",
+        parentEdge: "top",
+        direction: scrollDirection.value
+      });
+      observeItem({
+        childEdge: "top",
+        parentEdge: "bottom",
+        direction: scrollDirection.value
+      });
+      observeItem({
+        childEdge: "bottom",
+        parentEdge: "bottom",
+        direction: scrollDirection.value
+      });
+      observeItem({
+        childEdge: "bottom",
+        parentEdge: "top",
+        direction: scrollDirection.value
+      });
+      resetItem({
+        childEdge: "top",
+        parentEdge: "top",
+        direction: oppositeScrollDirection.value
+      });
+      resetItem({
+        childEdge: "top",
+        parentEdge: "bottom",
+        direction: oppositeScrollDirection.value
+      });
+      resetItem({
+        childEdge: "bottom",
+        parentEdge: "bottom",
+        direction: oppositeScrollDirection.value
+      });
+      resetItem({
+        childEdge: "bottom",
+        parentEdge: "top",
+        direction: oppositeScrollDirection.value
+      });
+    }
+  }
+  function reset() {
+    alerted.up.top.top = false;
+    alerted.up.top.bottom = false;
+    alerted.up.bottom.top = false;
+    alerted.up.bottom.bottom = false;
+    alerted.down.top.top = false;
+    alerted.down.top.bottom = false;
+    alerted.down.bottom.top = false;
+    alerted.down.bottom.bottom = false;
+  }
+  function observeItem(args2) {
+    const { childEdge, parentEdge, direction } = args2;
+    if (alerted[direction][childEdge][parentEdge]) {
+      return;
+    }
+    const offset2 = mappedOffset[parentEdge];
+    const mappedChildEdge = toValue(childBoundingRect[childEdge]);
+    const mappedParentEdge = toValue(parentBoundingRect[parentEdge]) + offset2;
+    if (direction === "down" && mappedChildEdge <= mappedParentEdge || direction === "up" && mappedChildEdge >= mappedParentEdge) {
+      alerted[direction][childEdge][parentEdge] = true;
+      useMagicEmitter().emit("collision", {
+        id,
+        direction,
+        parentEdge,
+        childEdge
+      });
+    }
+  }
+  function resetItem(args2) {
+    const { childEdge, parentEdge, direction } = args2;
+    if (!alerted[direction][childEdge][parentEdge]) {
+      return;
+    }
+    const offset2 = mappedOffset[parentEdge];
+    const mappedChildEdge = toValue(childBoundingRect[childEdge]);
+    const mappedParentEdge = toValue(parentBoundingRect[parentEdge]) + offset2;
+    if (direction === "down" && mappedChildEdge >= mappedParentEdge || direction === "up" && mappedChildEdge <= mappedParentEdge) {
+      alerted[direction][childEdge][parentEdge] = false;
+    }
+  }
+  return {
+    observe
+  };
+}

package/dist/plugins/MagicScroll/src/composables/private/useScrollApi.d.ts

@@ -1,10 +1,10 @@
 import { type MaybeRef, type MaybeRefOrGetter } from 'vue';
-import type { FromTo } from '../../types/index.js';
+import type { ScrollIntersection } from '../../types/index.js';
 type UseScrollApiParams = {
     child: MaybeRef<HTMLElement | null | undefined>;
     parent: MaybeRefOrGetter<HTMLElement | null | undefined>;
-    from: FromTo;
-    to: FromTo;
+    from: ScrollIntersection;
+    to: ScrollIntersection;
 };
 export declare function useScrollApi(params: UseScrollApiParams): {
     getCalculations: () => void;

package/dist/plugins/MagicScroll/src/composables/private/useScrollApi.mjs

@@ -1,14 +1,20 @@
-import { ref, inject, toValue } from "vue";
+import {
+  ref,
+  shallowRef,
+  inject,
+  toValue
+} from "vue";
 import { useWindowSize } from "@vueuse/core";
 import { MagicScrollReturn } from "../../symbols/index.mjs";
 import { clampValue } from "@maas/vue-equipment/utils";
 export function useScrollApi(params) {
   const { child, parent, from, to } = params;
   const scrollReturn = inject(MagicScrollReturn, void 0);
-  const childRect = ref();
-  const parentRect = ref();
-  const start = ref(0);
-  const end = ref(0);
+  const childRect = ref(void 0);
+  const parentRect = ref(void 0);
+  const start = shallowRef(0);
+  const end = shallowRef(0);
+  const { width: windowWidth, height: windowHeight } = useWindowSize();
   function splitLocation(location) {
     return {
       child: location.match(/^[a-z]+/)[0],
@@ -30,7 +36,9 @@ export function useScrollApi(params) {
         y += childRect.value.top + childRect.value.height + scrollY;
         break;
     }
-    if (!parentRect.value) return y;
+    if (!parentRect.value) {
+      return y;
+    }
     const dimensions = {
       width: toValue(parentRect.value.width),
       height: toValue(parentRect.value.height),
@@ -54,7 +62,11 @@ export function useScrollApi(params) {
   }
   function getCalculations() {
     childRect.value = toValue(child)?.getBoundingClientRect();
-    parentRect.value = toValue(parent) ? toValue(parent)?.getBoundingClientRect() : { ...useWindowSize(), top: 0 };
+    parentRect.value = toValue(parent) ? toValue(parent)?.getBoundingClientRect() : {
+      width: windowWidth.value,
+      height: windowHeight.value,
+      top: 0
+    };
     start.value = getOffsetTop(splitLocation(from));
     end.value = getOffsetTop(splitLocation(to));
   }

package/dist/plugins/MagicScroll/src/symbols/index.d.ts

@@ -1,6 +1,6 @@
 import type { InjectionKey, Ref, MaybeRef } from 'vue';
 import type { UseScrollReturn } from '@vueuse/core';
-declare const MagicScrollParent: InjectionKey<MaybeRef<HTMLElement | undefined>>;
+declare const MagicScrollTarget: InjectionKey<MaybeRef<HTMLElement | null | undefined>>;
 declare const MagicScrollProgress: InjectionKey<Ref<number>>;
 declare const MagicScrollReturn: InjectionKey<UseScrollReturn | undefined>;
-export { MagicScrollParent, MagicScrollProgress, MagicScrollReturn };
+export { MagicScrollTarget, MagicScrollProgress, MagicScrollReturn };

package/dist/plugins/MagicScroll/src/symbols/index.mjs

@@ -1,4 +1,4 @@
-const MagicScrollParent = Symbol();
+const MagicScrollTarget = Symbol();
 const MagicScrollProgress = Symbol();
 const MagicScrollReturn = Symbol();
-export { MagicScrollParent, MagicScrollProgress, MagicScrollReturn };
+export { MagicScrollTarget, MagicScrollProgress, MagicScrollReturn };

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

@@ -1,27 +1,17 @@
-export type Dimensions = {
-    width: number;
-    height: number;
-};
+import type { DOMKeyframesDefinition, AnimationOptions } from 'motion';
 export type ScrollDirection = 'up' | 'down';
-export type Position = 'top' | 'bottom';
-export type FromTo = 'top-top' | 'top-center' | 'top-bottom' | 'center-top' | 'center-center' | 'center-bottom' | 'bottom-top' | 'bottom-center' | 'bottom-bottom';
-export type Offset = number | (({ vw, vh }: {
-    vw: number;
-    vh: number;
-}) => number);
-export interface MagicScrollCollisionEntry {
-    offset?: {
-        top: Offset;
-        bottom: Offset;
-    };
-    element?: string;
-    data: Record<string, unknown>;
+export type CollisionEdge = 'top' | 'bottom';
+export type ScrollIntersection = 'top-top' | 'top-center' | 'top-bottom' | 'center-top' | 'center-center' | 'center-bottom' | 'bottom-top' | 'bottom-center' | 'bottom-bottom';
+export interface CollisionOffset {
+    top: number;
+    bottom: number;
 }
-export type ScrollEvents = {
+export interface ScrollEvents {
     collision: {
+        id: string;
         direction: ScrollDirection;
-        position: Position;
-        element: HTMLElement;
-        data?: Record<string, unknown>;
+        childEdge: CollisionEdge;
+        parentEdge: CollisionEdge;
     };
-};
+}
+export type MagicScrollSequence = [DOMKeyframesDefinition, AnimationOptions?][];

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

@@ -1,5 +1,6 @@
-import MagicToast from './src/components/MagicToast.vue.js';
 import { useMagicToast } from './src/composables/useMagicToast.js';
 import type { Plugin } from 'vue';
+import type { MagicToastOptions } from './src/types/index.js';
 declare const MagicToastPlugin: Plugin;
-export { MagicToastPlugin, MagicToast, useMagicToast };
+export { MagicToastPlugin, useMagicToast };
+export type { MagicToastOptions };