@maas/vue-equipment 0.29.2 → 0.29.4

package/dist/plugins/MagicCommand/src/components/MagicCommandProvider.vue

@@ -10,9 +10,9 @@ import { createDefu } from 'defu'
 import { useMagicKeys } from '@vueuse/core'
 import { defaultOptions } from '../utils/defaultOptions'
 import { useMagicCommand } from '../composables/useMagicCommand'
-import { MagicCommandInstanceId, MagicCommandOptions } from '../symbols'
+import { MagicCommandInstanceId, MagicCommandProviderOptions } from '../symbols'
 
-import type { CommandOptions } from './../types/index'
+import type { MagicCommandOptions } from './../types/index'
 
 // Prevent keys arrays from being merged with default
 const customDefu = createDefu((obj, key, value) => {
@@ -24,7 +24,7 @@ const customDefu = createDefu((obj, key, value) => {
 
 interface MagicCommandProps {
   id: MaybeRef<string>
-  options?: CommandOptions
+  options?: MagicCommandOptions
 }
 
 const props = withDefaults(defineProps<MagicCommandProps>(), {
@@ -62,5 +62,5 @@ onBeforeUnmount(() => {
 })
 
 provide(MagicCommandInstanceId, props.id)
-provide(MagicCommandOptions, mappedOptions)
+provide(MagicCommandProviderOptions, mappedOptions)
 </script>

package/dist/plugins/MagicCommand/src/components/MagicCommandProvider.vue.d.ts

@@ -1,15 +1,15 @@
 import { type MaybeRef } from 'vue';
-import type { CommandOptions } from './../types/index';
+import type { MagicCommandOptions } from './../types/index';
 interface MagicCommandProps {
     id: MaybeRef<string>;
-    options?: CommandOptions;
+    options?: MagicCommandOptions;
 }
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicCommandProps>, {
-    options: () => CommandOptions;
+    options: () => MagicCommandOptions;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicCommandProps>, {
-    options: () => CommandOptions;
+    options: () => MagicCommandOptions;
 }>>>, {
-    options: CommandOptions;
+    options: MagicCommandOptions;
 }, {}>, {
     default?(_: {}): any;
 }>;

package/dist/plugins/MagicCommand/src/components/MagicCommandView.vue

@@ -20,12 +20,14 @@ import { useCommandStore } from '../composables/private/useCommandStore'
 import { useCommandView } from '../composables/private/useCommandView'
 import { MagicCommandInstanceId } from '../symbols'
 
-interface Props {
+interface MagicCommandViewProps {
   id?: string
   default?: boolean
 }
 
-const props = withDefaults(defineProps<Props>(), { default: false })
+const props = withDefaults(defineProps<MagicCommandViewProps>(), {
+  default: false,
+})
 const commandId = inject(MagicCommandInstanceId, '')
 const elRef = ref<HTMLElement | undefined>(undefined)
 

package/dist/plugins/MagicCommand/src/components/MagicCommandView.vue.d.ts

@@ -1,10 +1,10 @@
-interface Props {
+interface MagicCommandViewProps {
     id?: string;
     default?: boolean;
 }
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicCommandViewProps>, {
     default: boolean;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicCommandViewProps>, {
     default: boolean;
 }>>>, {
     default: boolean;

package/dist/plugins/MagicCommand/src/composables/private/useCommandScroll.mjs

@@ -25,7 +25,7 @@ export function useCommandScroll(parent) {
     return elementRect.bottom >= parentBottom;
   }
   function findElement(id) {
-    return mappedParent.value.querySelector(`[data-item-id="${id}"]`);
+    return mappedParent.value.querySelector(`[data-id="${id}"]`);
   }
   function scrollInFromTop(element) {
     const elementRect = element.getBoundingClientRect();

package/dist/plugins/MagicCommand/src/composables/private/useCommandStore.mjs

@@ -18,7 +18,7 @@ export function useCommandStore() {
   function sortItems(id, parent) {
     const instance = findInstance(id);
     if (instance) {
-      const itemElements = parent.querySelectorAll("[data-item-id]");
+      const itemElements = parent.querySelectorAll("[data-id]");
       itemElements.forEach((el, index) => {
         const itemId = el.dataset.itemId;
         const item = instance.items?.find((item2) => item2.id === itemId);

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

@@ -1,5 +1,5 @@
 import type { InjectionKey, MaybeRef } from 'vue';
-import type { CommandOptions } from '../types.js';
+import type { MagicCommandOptions } from '../types.js';
 declare const MagicCommandInstanceId: InjectionKey<MaybeRef<string>>;
-declare const MagicCommandOptions: InjectionKey<CommandOptions>;
-export { MagicCommandInstanceId, MagicCommandOptions };
+declare const MagicCommandProviderOptions: InjectionKey<MagicCommandOptions>;
+export { MagicCommandInstanceId, MagicCommandProviderOptions };

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

@@ -1,3 +1,3 @@
 const MagicCommandInstanceId = Symbol();
-const MagicCommandOptions = Symbol();
-export { MagicCommandInstanceId, MagicCommandOptions };
+const MagicCommandProviderOptions = Symbol();
+export { MagicCommandInstanceId, MagicCommandProviderOptions };

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

@@ -1,6 +1,6 @@
-import type { ModalOptions } from '../../../MagicModal.js';
-import type { DrawerOptions } from '../../../MagicDrawer.js';
-export type CommandOptions = {
+import type { MagicModalOptions } from '../../../MagicModal.js';
+import type { MagicDrawerOptions } from '../../../MagicDrawer.js';
+export type MagicCommandOptions = {
     keys?: {
         open?: string[] | false;
         close?: string[] | false;
@@ -17,7 +17,7 @@ export type CommandEvents = {
     leave: string;
     afterLeave: string;
 };
-export interface CommandModalOptions extends ModalOptions {
+export interface MagicCommandModalOptions extends MagicModalOptions {
 }
-export interface CommandDrawerOptions extends DrawerOptions {
+export interface MagicCommandDrawerOptions extends MagicDrawerOptions {
 }

package/dist/plugins/MagicCommand/src/utils/defaultOptions.d.ts

@@ -1,5 +1,5 @@
-import type { CommandOptions } from '../types.js';
+import type { MagicCommandOptions } from '../types.js';
 import type { RequireAllNested } from '@maas/vue-equipment/utils';
-declare const defaultOptions: RequireAllNested<CommandOptions>;
+declare const defaultOptions: RequireAllNested<MagicCommandOptions>;
 type DefaultOptions = typeof defaultOptions;
 export { defaultOptions, type DefaultOptions };

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

@@ -1,7 +1,5 @@
 import type { Plugin } from 'vue';
 import MagicCookie from './src/components/MagicCookie.vue.js';
 import { useMagicCookie } from './src/composables/useMagicCookie.js';
-import type { CookieEvents } from './src/types/index.js';
 declare const MagicCookiePlugin: Plugin;
 export { MagicCookiePlugin, MagicCookie, useMagicCookie };
-export type { CookieEvents };

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

@@ -82,27 +82,26 @@
 </template>
 
 <script lang="ts" setup>
-import { defineCookieApi } from '../composables/private/defineCookieApi'
+import { useCookieApi } from '../composables/private/useCookieApi'
 import { useMagicCookie } from '../composables/useMagicCookie'
-import type { CookieRecord } from '../types'
+import type { MagicCookieRecord } from '../types'
 
 // Define the props and their default values
-type Props = {
-  cookies: CookieRecord[]
+type MagicCookieProps = {
+  cookies: MagicCookieRecord[]
   maxAge?: number
 }
 
-const props = withDefaults(defineProps<Props>(), {
+const props = withDefaults(defineProps<MagicCookieProps>(), {
   maxAge: 60 * 60 * 24 * 30,
 })
 
 // Initialize the Cookie API
-defineCookieApi({
+useCookieApi({
   cookies: props.cookies,
   maxAge: props.maxAge,
 })
 
-// Use the Cookie API
 const {
   preferencesVisible,
   selectedCookies,

package/dist/plugins/MagicCookie/src/components/MagicCookie.vue.d.ts

@@ -1,16 +1,16 @@
-import type { CookieRecord } from '../types';
-type Props = {
-    cookies: CookieRecord[];
+import type { MagicCookieRecord } from '../types';
+type MagicCookieProps = {
+    cookies: MagicCookieRecord[];
     maxAge?: number;
 };
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicCookieProps>, {
     maxAge: number;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicCookieProps>, {
     maxAge: number;
 }>>>, {
     maxAge: number;
 }, {}>, Partial<Record<string, (_: {
-    cookie: CookieRecord;
+    cookie: MagicCookieRecord;
 }) => any>> & {
     default?(_: {}): any;
     actions?(_: {}): any;

package/dist/plugins/MagicCookie/src/composables/private/useCookieApi.d.ts

@@ -0,0 +1,17 @@
+import type { MagicCookieRecord } from '../../types.js';
+type UseCookieApiArgs = {
+    cookies: MagicCookieRecord[];
+    maxAge?: number;
+};
+export declare const cookieApiStore: import("vue").Ref<{
+    cookies: {
+        [x: string]: unknown;
+        key: string;
+        optional?: boolean | undefined;
+        title?: string | undefined;
+        text?: string | undefined;
+    }[];
+    maxAge: number | undefined;
+}>;
+export declare function useCookieApi({ cookies, maxAge }: UseCookieApiArgs): void;
+export {};

package/dist/plugins/MagicCookie/src/composables/private/{defineCookieApi.mjs → useCookieApi.mjs}

@@ -1,14 +1,14 @@
 import { ref } from "vue";
 import { slugify } from "@maas/vue-equipment/utils";
-export const globalApiState = ref({
+export const cookieApiStore = ref({
   cookies: [],
   maxAge: void 0
 });
-export function defineCookieApi({ cookies, maxAge }) {
+export function useCookieApi({ cookies, maxAge }) {
   if (!Array.isArray(cookies)) {
     console.warn('Invalid configuration. "cookies" must be an array.');
   }
-  globalApiState.value.cookies = cookies?.map((cookie) => {
+  cookieApiStore.value.cookies = cookies?.map((cookie) => {
     return {
       ...cookie,
       key: slugify(cookie.key, {
@@ -18,5 +18,5 @@ export function defineCookieApi({ cookies, maxAge }) {
       })
     };
   });
-  globalApiState.value.maxAge = maxAge;
+  cookieApiStore.value.maxAge = maxAge;
 }

package/dist/plugins/MagicCookie/src/composables/useMagicCookie.d.ts

@@ -1,16 +1,16 @@
-import type { CookieConsent } from '../types.js';
+import type { MagicCookieConsent } from '../types.js';
 export declare function useMagicCookie(): {
     preferencesVisible: import("vue").Ref<boolean>;
     selectedCookies: import("vue").Ref<{
         [key: string]: boolean;
     }>;
-    cookieConsent: import("vue").WritableComputedRef<CookieConsent>;
+    cookieConsent: import("vue").WritableComputedRef<MagicCookieConsent>;
     toggleSelection: (key: string) => void;
     accept: () => void;
     acceptSelected: () => void;
     reject: () => void;
-    onAccept: (handler: (args: CookieConsent) => void) => void;
-    onAcceptSelected: (handler: (args: CookieConsent) => void) => void;
-    onReject: (handler: (args: CookieConsent) => void) => void;
+    onAccept: (handler: (args: MagicCookieConsent) => void) => void;
+    onAcceptSelected: (handler: (args: MagicCookieConsent) => void) => void;
+    onReject: (handler: (args: MagicCookieConsent) => void) => void;
 };
 export type UseMagicCookieReturn = ReturnType<typeof useMagicCookie>;

package/dist/plugins/MagicCookie/src/composables/useMagicCookie.mjs

@@ -2,7 +2,7 @@ import { computed, ref } from "vue";
 import { useCookies } from "@vueuse/integrations/useCookies";
 import { toValue } from "@vueuse/core";
 import { useMagicEmitter } from "@maas/vue-equipment/plugins";
-import { globalApiState } from "./private/defineCookieApi.mjs";
+import { cookieApiStore } from "./private/useCookieApi.mjs";
 const preferencesVisible = ref(false);
 const selectedCookies = ref({});
 export function useMagicCookie() {
@@ -13,7 +13,7 @@ export function useMagicCookie() {
     },
     set: (value) => {
       universalCookies.set("cookie_consent", value, {
-        maxAge: globalApiState.value?.maxAge
+        maxAge: cookieApiStore.value?.maxAge
       });
     }
   });
@@ -26,7 +26,7 @@ export function useMagicCookie() {
     };
   }
   function accept() {
-    const cookies = globalApiState.value?.cookies?.reduce((result, cookie) => {
+    const cookies = cookieApiStore.value?.cookies?.reduce((result, cookie) => {
       result[cookie.key] = true;
       return result;
     }, {});
@@ -44,7 +44,7 @@ export function useMagicCookie() {
     emitter.emit("acceptSelected", cookieConsent.value);
   }
   function reject() {
-    const cookies = globalApiState.value?.cookies?.reduce((result, cookie) => {
+    const cookies = cookieApiStore.value?.cookies?.reduce((result, cookie) => {
       result[cookie.key] = cookie.optional === false ? true : false;
       return result;
     }, {});

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

@@ -1,20 +1,16 @@
-export type CookieApiDefinition = {
-    cookies: CookieRecord[];
-    maxAge?: number;
-};
-export type CookieRecord = {
+export type MagicCookieRecord = {
     key: string;
     optional?: boolean;
     title?: string;
     text?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 };
-export type CookieConsent = {
+export type MagicCookieConsent = {
     timestamp: number | undefined;
     cookies: Record<string, boolean>;
 };
 export type CookieEvents = {
-    accept: CookieConsent;
-    reject: CookieConsent;
-    acceptSelected: CookieConsent;
+    accept: MagicCookieConsent;
+    reject: MagicCookieConsent;
+    acceptSelected: MagicCookieConsent;
 };

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

@@ -1,6 +1,6 @@
 import type { Plugin } from 'vue';
 import MagicDraggable from './src/components/MagicDraggable.vue.js';
-import type { DraggableOptions, DraggableEvents } from './src/types.js';
+import type { MagicDraggableOptions } from './src/types.js';
 declare const MagicDraggablePlugin: Plugin;
 export { MagicDraggablePlugin, MagicDraggable };
-export type { DraggableOptions, DraggableEvents };
+export type { MagicDraggableOptions };

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

@@ -1,16 +1,15 @@
 <template>
   <div
     ref="drawerRef"
-    class="magic-draggable"
     :id="toValue(id)"
     :class="[
-      toValue(props.class),
-
+      'magic-draggable',
       {
         '-dragging': dragging,
         '-disabled': disabled,
       },
     ]"
+    v-bind="$attrs"
   >
     <div class="magic-draggable__wrapper" ref="wrapperRef">
       <component
@@ -43,17 +42,19 @@ import { useDraggableDrag } from '../composables/private/useDraggableDrag'
 import { useDraggableState } from '../composables/private/useDraggableState'
 import { defaultOptions } from '../utils/defaultOptions'
 
-import type { DraggableOptions } from '../types'
+import type { MagicDraggableOptions } from '../types'
+
+defineOptions({
+  inheritAttrs: false,
+})
 
-interface MagicDrawerProps {
+interface MagicDraggableProps {
   id: MaybeRef<string>
-  class?: MaybeRef<string>
   component?: Component
-  props?: Record<string, unknown>
-  options?: DraggableOptions
+  options?: MagicDraggableOptions
 }
 
-const props = withDefaults(defineProps<MagicDrawerProps>(), {
+const props = withDefaults(defineProps<MagicDraggableProps>(), {
   options: () => defaultOptions,
 })
 

package/dist/plugins/MagicDraggable/src/components/MagicDraggable.vue.d.ts

@@ -1,18 +1,16 @@
 import { type Component, type MaybeRef } from 'vue';
-import type { DraggableOptions } from '../types';
-interface MagicDrawerProps {
+import type { MagicDraggableOptions } from '../types';
+interface MagicDraggableProps {
     id: MaybeRef<string>;
-    class?: MaybeRef<string>;
     component?: Component;
-    props?: Record<string, unknown>;
-    options?: DraggableOptions;
+    options?: MagicDraggableOptions;
 }
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicDrawerProps>, {
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicDraggableProps>, {
     options: () => any;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicDrawerProps>, {
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicDraggableProps>, {
     options: () => any;
 }>>>, {
-    options: DraggableOptions;
+    options: MagicDraggableOptions;
 }, {}>, {
     default?(_: {}): any;
 }>;

package/dist/plugins/MagicDraggable/src/composables/private/useDraggableState.d.ts

@@ -1,6 +1,5 @@
 import { type MaybeRef } from 'vue';
-import type { DraggableState } from '../../types/index.js';
 export declare function useDraggableState(id: MaybeRef<string>): {
-    initializeState: () => import("vue").ToRefs<DraggableState>;
+    initializeState: () => import("vue").ToRefs<any>;
     deleteState: () => void;
 };

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

@@ -10,7 +10,7 @@ export type DraggableSnapPoint = [
         y?: number;
     }
 ] | Position;
-export interface DraggableOptions {
+export interface MagicDraggableOptions {
     tag?: 'dialog' | 'div';
     threshold?: {
         distance?: number;

package/dist/plugins/MagicDraggable/src/utils/defaultOptions.d.ts

@@ -1,8 +1,8 @@
-import type { DraggableOptions } from '../types.js';
+import type { MagicDraggableOptions } from '../types.js';
 import type { RequireAll } from '@maas/vue-equipment/utils';
-type DefaultOptions = RequireAll<DraggableOptions> & {
-    threshold: RequireAll<DraggableOptions['threshold']>;
-    animation: RequireAll<DraggableOptions['animation']>;
+type DefaultOptions = RequireAll<MagicDraggableOptions> & {
+    threshold: RequireAll<MagicDraggableOptions['threshold']>;
+    animation: RequireAll<MagicDraggableOptions['animation']>;
 };
 declare const defaultOptions: DefaultOptions;
 export { defaultOptions, type DefaultOptions };

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

@@ -1,7 +1,7 @@
 import MagicDrawer from './src/components/MagicDrawer.vue.js';
 import { useMagicDrawer } from './src/composables/useMagicDrawer.js';
 import type { Plugin } from 'vue';
-import type { DrawerEvents, DrawerOptions } from './src/types/index.js';
+import type { MagicDrawerOptions } from './src/types/index.js';
 declare const MagicDrawerPlugin: Plugin;
 export { MagicDrawerPlugin, MagicDrawer, useMagicDrawer };
-export type { DrawerEvents, DrawerOptions };
+export type { MagicDrawerOptions };

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

@@ -6,10 +6,9 @@
   >
     <div
       ref="drawerRef"
-      class="magic-drawer"
       :id="toValue(id)"
       :class="[
-        toValue(props.class),
+        'magic-drawer',
         `-${mappedOptions.position}`,
         {
           '-dragging': dragging,
@@ -17,6 +16,7 @@
           '-disabled': disabled,
         },
       ]"
+      v-bind="$attrs"
       aria-modal="true"
     >
       <transition
@@ -75,7 +75,6 @@ import {
   nextTick,
   toValue,
   onBeforeMount,
-  onMounted,
   onBeforeUnmount,
   onUnmounted,
   type Component,
@@ -92,7 +91,7 @@ import { useDrawerDrag } from '../composables/private/useDrawerDrag'
 import { useDrawerWheel } from '../composables/private/useDrawerWheel'
 import { useDrawerState } from '../composables/private/useDrawerState'
 
-import type { DrawerOptions } from '../types/index'
+import type { MagicDrawerOptions } from '../types/index'
 
 import '@maas/vue-equipment/utils/css/animations/fade-in.css'
 import '@maas/vue-equipment/utils/css/animations/fade-out.css'
@@ -106,10 +105,14 @@ import '@maas/vue-equipment/utils/css/animations/slide-ttb-out.css'
 import '@maas/vue-equipment/utils/css/animations/slide-btt-out.css'
 import { useMagicDrawer } from '../composables/useMagicDrawer'
 
+defineOptions({
+  inheritAttrs: false,
+})
+
 // Prevent deep merge of certain options
 // In this case, don’t merge the `close` and `points` options
 const customDefu = createDefu((obj, key, value) => {
-  if (key === 'close' || key === 'points') {
+  if (key === 'close' || key === 'snapPoints') {
     obj[key] = value
     return true
   }
@@ -117,10 +120,8 @@ const customDefu = createDefu((obj, key, value) => {
 
 interface MagicDrawerProps {
   id: MaybeRef<string>
-  class?: MaybeRef<string>
   component?: Component
-  props?: Record<string, unknown>
-  options?: DrawerOptions
+  options?: MagicDrawerOptions
 }
 
 const props = withDefaults(defineProps<MagicDrawerProps>(), {

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

@@ -1,5 +1,5 @@
 import { type Component, type MaybeRef } from 'vue';
-import type { DrawerOptions } from '../types/index';
+import type { MagicDrawerOptions } from '../types/index';
 import '@maas/vue-equipment/utils/css/animations/fade-in.css';
 import '@maas/vue-equipment/utils/css/animations/fade-out.css';
 import '@maas/vue-equipment/utils/css/animations/slide-ltr-in.css';
@@ -12,17 +12,15 @@ import '@maas/vue-equipment/utils/css/animations/slide-ttb-out.css';
 import '@maas/vue-equipment/utils/css/animations/slide-btt-out.css';
 interface MagicDrawerProps {
     id: MaybeRef<string>;
-    class?: MaybeRef<string>;
     component?: Component;
-    props?: Record<string, unknown>;
-    options?: DrawerOptions;
+    options?: MagicDrawerOptions;
 }
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicDrawerProps>, {
     options: () => any;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MagicDrawerProps>, {
     options: () => any;
 }>>>, {
-    options: DrawerOptions;
+    options: MagicDrawerOptions;
 }, {}>, {
     backdrop?(_: {}): any;
     default?(_: {}): any;

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

@@ -1,8 +1,8 @@
 import { type Ref, type MaybeRef } from 'vue';
-import type { DrawerOptions } from '../../types.js';
+import type { MagicDrawerOptions } from '../../types.js';
 type UseDrawerCallbackArgs = {
     id: MaybeRef<string>;
-    mappedOptions: DrawerOptions;
+    mappedOptions: MagicDrawerOptions;
     addScrollLockPadding: () => void;
     removeScrollLockPadding: () => void;
     lockScroll: () => void;

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

@@ -1,9 +1,9 @@
 import { type MaybeElementRef } from '@vueuse/core';
-import type { DrawerOptions } from '../../types/index.js';
-export type UseDrawerDOMOptions = Pick<DrawerOptions, 'scrollLock' | 'focusTrap'> & {
+import type { MagicDrawerOptions } from '../../types/index.js';
+export type UseDrawerDOMArgs = Pick<MagicDrawerOptions, 'scrollLock' | 'focusTrap'> & {
     focusTarget: MaybeElementRef;
 };
-export declare function useDrawerDOM(options?: UseDrawerDOMOptions): {
+export declare function useDrawerDOM(args?: UseDrawerDOMArgs): {
     trapFocus: () => void;
     releaseFocus: () => void;
     lockScroll: () => void;

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

@@ -9,9 +9,9 @@ const defaultOptions = {
   scrollLock: true
 };
 const scrollLock = typeof window !== "undefined" ? useScrollLock(document?.documentElement) : ref(false);
-export function useDrawerDOM(options) {
+export function useDrawerDOM(args) {
   const positionFixedElements = ref([]);
-  const mappedOptions = defu(options, defaultOptions);
+  const mappedOptions = defu(args, defaultOptions);
   const focusTrap = mappedOptions.focusTarget ? typeof mappedOptions.focusTrap === "boolean" ? useFocusTrap(mappedOptions.focusTarget) : useFocusTrap(mappedOptions.focusTarget, mappedOptions.focusTrap) : void 0;
   function trapFocus() {
     if (focusTrap) {

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

@@ -14,7 +14,9 @@ import {
   useScrollLock
 } from "@vueuse/core";
 import { isIOS, isWithinRange } from "@maas/vue-equipment/utils";
-import { useMagicEmitter } from "@maas/vue-equipment/plugins";
+import {
+  useMagicEmitter
+} from "@maas/vue-equipment/plugins";
 import { useDrawerSnap } from "./useDrawerSnap.mjs";
 import { useDrawerGuards } from "./useDrawerGuards.mjs";
 import { useDrawerUtils } from "./useDrawerUtils.mjs";

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

@@ -8,7 +8,9 @@ import {
 } from "vue";
 import { useElementBounding, useRafFn } from "@vueuse/core";
 import { clampValue, mapValue } from "@maas/vue-equipment/utils";
-import { useMagicEmitter } from "@maas/vue-equipment/plugins";
+import {
+  useMagicEmitter
+} from "@maas/vue-equipment/plugins";
 import { useDrawerState } from "./useDrawerState.mjs";
 export function useDrawerProgress(args) {
   const { id, drawerRef, elRef, position, overshoot } = args;