@vuetify/nightly 3.2.0-dev-20230214.0 → 3.2.0-dev-20230322.0

package/lib/components/VOverlay/index.d.ts

@@ -1,5 +1,5 @@
 import * as vue from 'vue';
-import { Ref, EffectScope } from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, Ref, EffectScope, PropType } from 'vue';
 
 declare const block: readonly ["top", "bottom"];
 declare const inline: readonly ["start", "end", "left", "right"];
@@ -24,6 +24,10 @@ declare class Box {
     get right(): number;
 }
 
+interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions>, Props = ExtractPropTypes<PropsOptions>> {
+    filterProps<T extends Partial<Props>, U extends Exclude<keyof Props, Exclude<keyof Props, keyof T>>>(props: T): [yes: Partial<Pick<T, U>>, no: Omit<T, U>];
+}
+
 interface LocationStrategyData {
     contentEl: Ref<HTMLElement | undefined>;
     activatorEl: Ref<HTMLElement | undefined>;
@@ -80,7 +84,362 @@ declare function closeScrollStrategy(data: ScrollStrategyData): void;
 declare function blockScrollStrategy(data: ScrollStrategyData, props: StrategyProps): void;
 declare function repositionScrollStrategy(data: ScrollStrategyData, props: StrategyProps, scope: EffectScope): void;
 
-declare const VOverlay: vue.DefineComponent<{
+declare const VOverlay: {
+    new (...args: any[]): {
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }> & Omit<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            theme?: string | undefined;
+            contentClass?: any;
+            activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                default?: ((args_0: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            };
+            $slots?: {
+                default?: ((args_0: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            'v-slots'?: {
+                default?: false | ((args_0: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((args_0: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            onAfterLeave?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: vue.Slot | undefined;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $emit: ((event: "update:modelValue", value: boolean) => void) & ((event: "click:outside", e: MouseEvent) => void) & ((event: "afterLeave") => void);
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            theme?: string | undefined;
+            contentClass?: any;
+            activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                default?: ((args_0: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            };
+            $slots?: {
+                default?: ((args_0: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            'v-slots'?: {
+                default?: false | ((args_0: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((args_0: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            onAfterLeave?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        }, {
+            activatorEl: Ref<HTMLElement | undefined>;
+            animateClick: () => void;
+            contentEl: Ref<HTMLElement | undefined>;
+            globalTop: Readonly<Ref<boolean>>;
+            localTop: vue.ComputedRef<boolean>;
+            updateLocation: Ref<((e: Event) => void) | undefined>;
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+            'click:outside': (e: MouseEvent) => true;
+            'update:modelValue': (value: boolean) => true;
+            afterLeave: () => true;
+        }, string, {
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }, {}, string> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof vue.nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+    } & {
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        });
+        zIndex: string | number;
+        eager: boolean;
+        disabled: boolean;
+        modelValue: boolean;
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined);
+        scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        offset?: string | number | number[] | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        theme?: string | undefined;
+        contentClass?: any;
+        activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } & {
+        $children?: {} | vue.VNodeChild | {
+            default?: ((args_0: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        };
+        $slots?: {
+            default?: ((args_0: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+        'v-slots'?: {
+            default?: false | ((args_0: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((args_0: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((args_0: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        onAfterLeave?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    } & vue.ShallowUnwrapRef<{
+        activatorEl: Ref<HTMLElement | undefined>;
+        animateClick: () => void;
+        contentEl: Ref<HTMLElement | undefined>;
+        globalTop: Readonly<Ref<boolean>>;
+        localTop: vue.ComputedRef<boolean>;
+        updateLocation: Ref<((e: Event) => void) | undefined>;
+    }> & {} & vue.ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
     absolute: boolean;
     location: Anchor;
     origin: "auto" | Anchor | "overlap";
@@ -131,77 +490,7 @@ declare const VOverlay: vue.DefineComponent<{
             props: Record<string, any>;
         }) => vue.VNodeChild) | undefined;
     };
-    'v-slots'?: {
-        default?: false | ((args_0: {
-            isActive: Ref<boolean>;
-        }) => vue.VNodeChild) | undefined;
-        activator?: false | ((args_0: {
-            isActive: boolean;
-            props: Record<string, any>;
-        }) => vue.VNodeChild) | undefined;
-    } | undefined;
-} & {
-    "v-slot:default"?: false | ((args_0: {
-        isActive: Ref<boolean>;
-    }) => vue.VNodeChild) | undefined;
-    "v-slot:activator"?: false | ((args_0: {
-        isActive: boolean;
-        props: Record<string, any>;
-    }) => vue.VNodeChild) | undefined;
-}, {
-    activatorEl: Ref<HTMLElement | undefined>;
-    animateClick: () => void;
-    contentEl: Ref<HTMLElement | undefined>;
-    globalTop: Readonly<Ref<boolean>>;
-    localTop: vue.ComputedRef<boolean>;
-    updateLocation: Ref<((e: Event) => void) | undefined>;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
-    'click:outside': (e: MouseEvent) => true;
-    'update:modelValue': (value: boolean) => true;
-    afterLeave: () => true;
-}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
-    absolute: boolean;
-    location: Anchor;
-    origin: "auto" | Anchor | "overlap";
-    transition: string | boolean | (vue.TransitionProps & {
-        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-    });
-    zIndex: string | number;
-    eager: boolean;
-    disabled: boolean;
-    modelValue: boolean;
-    activatorProps: Record<string, any>;
-    openOnHover: boolean;
-    closeOnContentClick: boolean;
-    locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => {
-        updateLocation: (e: Event) => void;
-    } | undefined);
-    scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
-    closeOnBack: boolean;
-    contained: boolean;
-    noClickAnimation: boolean;
-    persistent: boolean;
-    scrim: string | boolean;
-    _disableGlobalStack: boolean;
-} & {
-    offset?: string | number | number[] | undefined;
-    height?: string | number | undefined;
-    width?: string | number | undefined;
-    maxHeight?: string | number | undefined;
-    maxWidth?: string | number | undefined;
-    minHeight?: string | number | undefined;
-    minWidth?: string | number | undefined;
-    theme?: string | undefined;
-    contentClass?: any;
-    activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
-    closeDelay?: string | number | undefined;
-    openDelay?: string | number | undefined;
-    openOnClick?: boolean | undefined;
-    openOnFocus?: boolean | undefined;
-    contentProps?: any;
-    attach?: string | boolean | Element | undefined;
-} & {
-    $children?: {} | vue.VNodeChild | {
+    $slots?: {
         default?: ((args_0: {
             isActive: Ref<boolean>;
         }) => vue.VNodeChild) | undefined;
@@ -209,7 +498,7 @@ declare const VOverlay: vue.DefineComponent<{
             isActive: boolean;
             props: Record<string, any>;
         }) => vue.VNodeChild) | undefined;
-    };
+    } | undefined;
     'v-slots'?: {
         default?: false | ((args_0: {
             isActive: Ref<boolean>;
@@ -232,6 +521,17 @@ declare const VOverlay: vue.DefineComponent<{
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
 }, {
+    activatorEl: Ref<HTMLElement | undefined>;
+    animateClick: () => void;
+    contentEl: Ref<HTMLElement | undefined>;
+    globalTop: Readonly<Ref<boolean>>;
+    localTop: vue.ComputedRef<boolean>;
+    updateLocation: Ref<((e: Event) => void) | undefined>;
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'click:outside': (e: MouseEvent) => true;
+    'update:modelValue': (value: boolean) => true;
+    afterLeave: () => true;
+}, string, {
     absolute: boolean;
     location: Anchor;
     origin: "auto" | Anchor | "overlap";
@@ -257,7 +557,159 @@ declare const VOverlay: vue.DefineComponent<{
     persistent: boolean;
     scrim: string | boolean;
     _disableGlobalStack: boolean;
-}>;
+}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    transition: {
+        type: PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    theme: StringConstructor;
+    scrollStrategy: {
+        type: PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    locationStrategy: {
+        type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    location: {
+        type: PropType<Anchor>;
+        default: string;
+    };
+    origin: {
+        type: PropType<"auto" | Anchor | "overlap">;
+        default: string;
+    };
+    offset: PropType<string | number | number[] | undefined>;
+    eager: BooleanConstructor;
+    height: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    closeDelay: (StringConstructor | NumberConstructor)[];
+    openDelay: (StringConstructor | NumberConstructor)[];
+    activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined>;
+    activatorProps: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    openOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openOnHover: BooleanConstructor;
+    openOnFocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    closeOnContentClick: BooleanConstructor;
+    absolute: BooleanConstructor;
+    attach: PropType<string | boolean | Element>;
+    closeOnBack: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contained: BooleanConstructor;
+    contentClass: null;
+    contentProps: null;
+    disabled: BooleanConstructor;
+    noClickAnimation: BooleanConstructor;
+    modelValue: BooleanConstructor;
+    persistent: BooleanConstructor;
+    scrim: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    _disableGlobalStack: BooleanConstructor;
+}, vue.ExtractPropTypes<{
+    transition: {
+        type: PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    theme: StringConstructor;
+    scrollStrategy: {
+        type: PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    locationStrategy: {
+        type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    location: {
+        type: PropType<Anchor>;
+        default: string;
+    };
+    origin: {
+        type: PropType<"auto" | Anchor | "overlap">;
+        default: string;
+    };
+    offset: PropType<string | number | number[] | undefined>;
+    eager: BooleanConstructor;
+    height: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    closeDelay: (StringConstructor | NumberConstructor)[];
+    openDelay: (StringConstructor | NumberConstructor)[];
+    activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined>;
+    activatorProps: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    openOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openOnHover: BooleanConstructor;
+    openOnFocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    closeOnContentClick: BooleanConstructor;
+    absolute: BooleanConstructor;
+    attach: PropType<string | boolean | Element>;
+    closeOnBack: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contained: BooleanConstructor;
+    contentClass: null;
+    contentProps: null;
+    disabled: BooleanConstructor;
+    noClickAnimation: BooleanConstructor;
+    modelValue: BooleanConstructor;
+    persistent: BooleanConstructor;
+    scrim: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    _disableGlobalStack: BooleanConstructor;
+}>>;
 type VOverlay = InstanceType<typeof VOverlay>;
 
 export { VOverlay };

package/lib/components/VOverlay/scrollStrategies.mjs

@@ -23,7 +23,7 @@ export function useScrollStrategies(props, data) {
     if (!(data.isActive.value && props.scrollStrategy)) return;
     scope = effectScope();
     await nextTick();
-    scope.run(() => {
+    scope.active && scope.run(() => {
       if (typeof props.scrollStrategy === 'function') {
         props.scrollStrategy(data, props, scope);
       } else {
@@ -104,7 +104,7 @@ function repositionScrollStrategy(data, props, scope) {
     });
   });
   onScopeDispose(() => {
-    cancelIdleCallback(ric);
+    typeof cancelIdleCallback !== 'undefined' && cancelIdleCallback(ric);
     cancelAnimationFrame(raf);
   });
 }