@bitrix24/b24ui-nuxt 0.6.6 → 0.6.8

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitrix24/b24ui-nuxt",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "docs": "https://bitrix24.github.io/b24ui/guide/installation-nuxt-app.html",
   "configKey": "b24ui",
   "compatibility": {

package/dist/module.mjs

@@ -1,11 +1,11 @@
 import { defu } from 'defu';
 import { defineNuxtModule, createResolver, addVitePlugin, addPlugin, addComponentsDir, addImportsDir, hasNuxtModule, installModule } from '@nuxt/kit';
-import { d as defaultOptions, a as getDefaultUiConfig, b as addTemplates } from './shared/b24ui-nuxt.BL9IkPeR.mjs';
+import { d as defaultOptions, a as getDefaultUiConfig, b as addTemplates } from './shared/b24ui-nuxt.jU270f-Q.mjs';
 import 'node:url';
 import 'scule';
 
 const name = "@bitrix24/b24ui-nuxt";
-const version = "0.6.6";
+const version = "0.6.8";
 
 const module = defineNuxtModule({
   meta: {

package/dist/runtime/components/App.vue

@@ -15,7 +15,7 @@ import B24OverlayProvider from "./OverlayProvider.vue";
 const props = defineProps({
   tooltip: { type: Object, required: false },
   toaster: { type: [Object, null], required: false },
-  locale: { type: null, required: false },
+  locale: { type: Object, required: false },
   portal: { type: null, required: false, default: "body" },
   scrollBody: { type: [Boolean, Object], required: false },
   nonce: { type: String, required: false }

package/dist/runtime/components/Calendar.vue

@@ -37,6 +37,7 @@ const props = defineProps({
   allowNonContiguousRanges: { type: Boolean, required: false },
   pagedNavigation: { type: Boolean, required: false },
   preventDeselect: { type: Boolean, required: false },
+  maximumDays: { type: Number, required: false },
   weekStartsOn: { type: Number, required: false },
   weekdayFormat: { type: String, required: false },
   fixedWeeks: { type: Boolean, required: false, default: true },
@@ -48,8 +49,11 @@ const props = defineProps({
   initialFocus: { type: Boolean, required: false },
   isDateDisabled: { type: Function, required: false },
   isDateUnavailable: { type: Function, required: false },
+  isDateHighlightable: { type: Function, required: false },
   nextPage: { type: Function, required: false },
-  prevPage: { type: Function, required: false }
+  prevPage: { type: Function, required: false },
+  disableDaysOutsideCurrentView: { type: Boolean, required: false },
+  fixedDate: { type: String, required: false }
 });
 const emits = defineEmits(["update:modelValue", "update:placeholder", "update:startValue"]);
 defineSlots();

package/dist/runtime/components/Checkbox.vue

@@ -23,7 +23,7 @@ const props = defineProps({
   disabled: { type: Boolean, required: false },
   required: { type: Boolean, required: false },
   name: { type: String, required: false },
-  value: { type: [String, Number, Object, null], required: false },
+  value: { type: null, required: false },
   id: { type: String, required: false },
   defaultValue: { type: [Boolean, String], required: false }
 });

package/dist/runtime/components/DescriptionList.vue

@@ -68,6 +68,12 @@ const normalizedItems = computed(() => {
         v-for="(item, index) in normalizedItems"
         :key="index"
       >
+        <slot
+          name="content-top"
+          :item="item"
+          :index="index"
+        />
+
         <slot
           :name="item.slot || 'content'"
           :item="item"
@@ -163,6 +169,12 @@ const normalizedItems = computed(() => {
             </span>
           </dd>
         </slot>
+
+        <slot
+          name="content-bottom"
+          :item="item"
+          :index="index"
+        />
       </template>
     </dl>
     <div

package/dist/runtime/components/DescriptionList.vue.d.ts

@@ -55,14 +55,16 @@ type SlotProps<T extends DescriptionListItem> = (props: {
     index: number;
 }) => any;
 export type DescriptionListSlots<T extends DescriptionListItem = DescriptionListItem> = {
-    legend(props?: {}): any;
-    text(props?: {}): any;
-    leading: SlotProps<T>;
-    label: SlotProps<T>;
-    description: SlotProps<T>;
-    actions: SlotProps<T>;
-    content: SlotProps<T>;
-    footer(props?: {
+    'legend'(props?: {}): any;
+    'text'(props?: {}): any;
+    'leading': SlotProps<T>;
+    'label': SlotProps<T>;
+    'description': SlotProps<T>;
+    'actions': SlotProps<T>;
+    'content-top': SlotProps<T>;
+    'content': SlotProps<T>;
+    'content-bottom': SlotProps<T>;
+    'footer'(props?: {
         b24ui: any;
     }): any;
 } & DynamicSlots<T, undefined, {

package/dist/runtime/components/DropdownMenu.vue.d.ts

@@ -92,6 +92,8 @@ export type DropdownMenuSlots<A extends ArrayOrNested<DropdownMenuItem> = ArrayO
     'item-leading': SlotProps<T>;
     'item-label': SlotProps<T>;
     'item-trailing': SlotProps<T>;
+    'content-top': (props?: {}) => any;
+    'content-bottom': (props?: {}) => any;
 } & DynamicSlots<MergeTypes<T>, 'leading' | 'label' | 'trailing', {
     active?: boolean;
     index: number;

package/dist/runtime/components/DropdownMenuContent.vue

@@ -117,6 +117,8 @@ const groups = computed(
 
   <DropdownMenu.Portal v-bind="portalProps">
     <component :is="sub ? DropdownMenu.SubContent : DropdownMenu.Content" :class="props.class" v-bind="contentProps">
+      <slot name="content-top" />
+
       <DropdownMenu.Group v-for="(group, groupIndex) in groups" :key="`group-${groupIndex}`" :class="b24ui.group({ class: b24uiOverride?.group })">
         <template v-for="(item, index) in group" :key="`group-${groupIndex}-${index}`">
           <DropdownMenu.Label v-if="item.type === 'label'" :class="b24ui.label({ class: b24uiOverride?.label })">
@@ -185,6 +187,8 @@ const groups = computed(
       </DropdownMenu.Group>
 
       <slot />
+
+      <slot name="content-bottom" />
     </component>
   </DropdownMenu.Portal>
 </template>

package/dist/runtime/components/InputMenu.vue

@@ -134,7 +134,7 @@ const createItem = computed(() => {
   }
   const newItem = props.valueKey ? { [props.valueKey]: searchTerm.value } : searchTerm.value;
   if (typeof props.createItem === "object" && props.createItem.when === "always" || props.createItem === "always") {
-    return !filteredItems.value.find((item) => compare(item, newItem, String(props.valueKey)));
+    return !filteredItems.value.find((item) => compare(item, newItem, props.valueKey));
   }
   return !filteredItems.value.length;
 });
@@ -330,6 +330,8 @@ defineExpose({
 
     <ComboboxPortal v-bind="portalProps">
       <ComboboxContent :class="b24ui.content({ class: props.b24ui?.content })" v-bind="contentProps">
+        <slot name="content-top" />
+
         <ComboboxEmpty :class="b24ui.empty({ class: props.b24ui?.empty })">
           <slot name="empty" :search-term="searchTerm">
             {{ searchTerm ? t('inputMenu.noMatch', { searchTerm }) : t('inputMenu.noData') }}
@@ -351,7 +353,7 @@ defineExpose({
                 v-else
                 :class="b24ui.item({ class: props.b24ui?.item, colorItem: isInputItem(item) ? item?.color : void 0 })"
                 :disabled="isInputItem(item) && item.disabled"
-                :value="props.valueKey && isInputItem(item) ? get(item, String(props.valueKey)) : item"
+                :value="props.valueKey && isInputItem(item) ? get(item, props.valueKey) : item"
                 @select="onSelect($event, item)"
               >
                 <slot name="item" :item="item" :index="index">
@@ -396,6 +398,8 @@ defineExpose({
           <ReuseCreateItemTemplate v-if="createItem && createItemPosition === 'bottom'" />
         </ComboboxViewport>
 
+        <slot name="content-bottom" />
+
         <ComboboxArrow v-if="!!arrow" v-bind="arrowProps" :class="b24ui.arrow({ class: props.b24ui?.arrow })" />
       </ComboboxContent>
     </ComboboxPortal>

package/dist/runtime/components/InputMenu.vue.d.ts

@@ -211,6 +211,8 @@ export interface InputMenuSlots<A extends ArrayOrNested<InputMenuItem> = ArrayOr
     'item-trailing': SlotProps<T>;
     'tags-item-text': SlotProps<T>;
     'tags-item-delete': SlotProps<T>;
+    'content-top': (props?: {}) => any;
+    'content-bottom': (props?: {}) => any;
     'create-item-label'(props: {
         item: string;
     }): any;
@@ -249,6 +251,110 @@ declare const _default: <T extends ArrayOrNested<InputMenuItem>, VK extends GetI
             };
             $refs: {
                 [x: string]: unknown;
+            } & {
+                primitiveElement: ({
+                    $: import("vue").ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly modelValue?: string | undefined;
+                        readonly autoFocus?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly asChild?: boolean | undefined;
+                        readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+                        readonly "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        primitiveElement: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                            asChild: boolean;
+                            as: import("reka-ui").AsTag | import("vue").Component;
+                        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import("vue").ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, {
+                            asChild: boolean;
+                            as: import("reka-ui").AsTag | import("vue").Component;
+                        }> | null;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import("vue").Slot<any> | undefined;
+                    }>;
+                    $root: import("vue").ComponentPublicInstance | null;
+                    $parent: import("vue").ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: "update:modelValue", args_0: string) => void;
+                    $el: any;
+                    $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ListboxFilterProps> & Readonly<{
+                        "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        "update:modelValue": (args_0: string) => any;
+                    }, string, {
+                        as: import("reka-ui").AsTag | import("vue").Component;
+                    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import("vue").nextTick;
+                    $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+                } & Readonly<{
+                    as: import("reka-ui").AsTag | import("vue").Component;
+                }> & Omit<Readonly<import("reka-ui").ListboxFilterProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                }>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+                    $slots: Readonly<{
+                        default?: (props: {
+                            modelValue: string | undefined;
+                        }) => any;
+                    }> & {
+                        default?: (props: {
+                            modelValue: string | undefined;
+                        }) => any;
+                    };
+                }) | null;
             };
             $slots: Readonly<{
                 [name: string]: import("vue").Slot<any> | undefined;
@@ -309,6 +415,110 @@ declare const _default: <T extends ArrayOrNested<InputMenuItem>, VK extends GetI
             };
             $refs: {
                 [x: string]: unknown;
+            } & {
+                primitiveElement: ({
+                    $: import("vue").ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly modelValue?: string | undefined;
+                        readonly autoFocus?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly asChild?: boolean | undefined;
+                        readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+                        readonly "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        primitiveElement: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                            asChild: boolean;
+                            as: import("reka-ui").AsTag | import("vue").Component;
+                        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import("vue").ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, {
+                            asChild: boolean;
+                            as: import("reka-ui").AsTag | import("vue").Component;
+                        }> | null;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import("vue").Slot<any> | undefined;
+                    }>;
+                    $root: import("vue").ComponentPublicInstance | null;
+                    $parent: import("vue").ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: "update:modelValue", args_0: string) => void;
+                    $el: any;
+                    $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ListboxFilterProps> & Readonly<{
+                        "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        "update:modelValue": (args_0: string) => any;
+                    }, string, {
+                        as: import("reka-ui").AsTag | import("vue").Component;
+                    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import("vue").nextTick;
+                    $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+                } & Readonly<{
+                    as: import("reka-ui").AsTag | import("vue").Component;
+                }> & Omit<Readonly<import("reka-ui").ListboxFilterProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                }>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+                    $slots: Readonly<{
+                        default?: (props: {
+                            modelValue: string | undefined;
+                        }) => any;
+                    }> & {
+                        default?: (props: {
+                            modelValue: string | undefined;
+                        }) => any;
+                    };
+                }) | null;
             };
             $slots: Readonly<{
                 [name: string]: import("vue").Slot<any> | undefined;

package/dist/runtime/components/InputNumber.vue.d.ts

@@ -117,6 +117,43 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<InputNumbe
         };
         $refs: {
             [x: string]: unknown;
+        } & {
+            primitiveElement: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                asChild: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                as: {
+                    type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                    default: string;
+                };
+            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                asChild: boolean;
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                asChild: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                as: {
+                    type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                    default: string;
+                };
+            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, {
+                asChild: boolean;
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }> | null;
         };
         $slots: Readonly<{
             [name: string]: import("vue").Slot<any> | undefined;
@@ -166,6 +203,43 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<InputNumbe
         };
         $refs: {
             [x: string]: unknown;
+        } & {
+            primitiveElement: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                asChild: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                as: {
+                    type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                    default: string;
+                };
+            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                asChild: boolean;
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                asChild: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                as: {
+                    type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                    default: string;
+                };
+            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, {
+                asChild: boolean;
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }> | null;
         };
         $slots: Readonly<{
             [name: string]: import("vue").Slot<any> | undefined;

package/dist/runtime/components/Modal.vue

@@ -31,7 +31,7 @@ const props = defineProps({
   defaultOpen: { type: Boolean, required: false },
   modal: { type: Boolean, required: false, default: true }
 });
-const emits = defineEmits(["after:leave", "update:open"]);
+const emits = defineEmits(["after:leave", "close:prevent", "update:open"]);
 const slots = defineSlots();
 const { t } = useLocale();
 const appConfig = useAppConfig();
@@ -39,18 +39,20 @@ const rootProps = useForwardPropsEmits(reactivePick(props, "open", "defaultOpen"
 const portalProps = usePortal(toRef(() => props.portal));
 const contentProps = toRef(() => props.content);
 const contentEvents = computed(() => {
-  const events = {
+  const defaultEvents = {
     closeAutoFocus: (e) => e.preventDefault()
   };
   if (!props.dismissible) {
-    return {
-      pointerDownOutside: (e) => e.preventDefault(),
-      interactOutside: (e) => e.preventDefault(),
-      escapeKeyDown: (e) => e.preventDefault(),
-      ...events
-    };
+    const events = ["pointerDownOutside", "interactOutside", "escapeKeyDown", "closeAutoFocus"];
+    return events.reduce((acc, curr) => {
+      acc[curr] = (e) => {
+        e.preventDefault();
+        emits("close:prevent");
+      };
+      return acc;
+    }, {});
   }
-  return events;
+  return defaultEvents;
 });
 const b24ui = computed(() => tv({ extend: tv(theme), ...appConfig.b24ui?.modal || {} })({
   transition: props.transition,

package/dist/runtime/components/Modal.vue.d.ts

@@ -63,6 +63,7 @@ export interface ModalProps extends DialogRootProps {
 }
 export interface ModalEmits extends DialogRootEmits {
     'after:leave': [];
+    'close:prevent': [];
 }
 export interface ModalSlots {
     default(props: {
@@ -83,9 +84,11 @@ export interface ModalSlots {
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ModalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
     "after:leave": () => any;
+    "close:prevent": () => any;
 }, string, import("vue").PublicProps, Readonly<ModalProps> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
     "onAfter:leave"?: (() => any) | undefined;
+    "onClose:prevent"?: (() => any) | undefined;
 }>, {
     close: boolean | Partial<ButtonProps>;
     modal: boolean;

package/dist/runtime/components/NavigationMenu.vue

@@ -229,6 +229,8 @@ const lists = computed(
     :class="b24ui.root({ class: [props.class, props.b24ui?.root] })"
     data-slot="section"
   >
+    <slot name="list-leading" />
+
     <template v-for="(list, listIndex) in lists" :key="`list-${listIndex}`">
       <NavigationMenuList :class="b24ui.list({ class: props.b24ui?.list })">
         <ReuseItemTemplate
@@ -243,6 +245,8 @@ const lists = computed(
       <div v-if="orientation === 'vertical' && listIndex < lists.length - 1" :class="b24ui.separator({ class: props.b24ui?.separator })" />
     </template>
 
+    <slot name="list-trailing" />
+
     <div v-if="orientation === 'horizontal'" :class="b24ui.viewportWrapper({ class: props.b24ui?.viewportWrapper })">
       <NavigationMenuIndicator v-if="arrow" :class="b24ui.indicator({ class: props.b24ui?.indicator })">
         <div :class="b24ui.arrow({ class: props.b24ui?.arrow })" />

package/dist/runtime/components/NavigationMenu.vue.d.ts

@@ -122,6 +122,8 @@ export type NavigationMenuSlots<A extends ArrayOrNested<NavigationMenuItem> = Ar
     'item-label': SlotProps<T>;
     'item-trailing': SlotProps<T>;
     'item-content': SlotProps<T>;
+    'list-leading': (props?: {}) => any;
+    'list-trailing': (props?: {}) => any;
 } & DynamicSlots<MergeTypes<T>, 'leading' | 'label' | 'trailing' | 'content', {
     index: number;
     active?: boolean;

package/dist/runtime/components/Popover.vue

@@ -25,7 +25,7 @@ const props = defineProps({
   openDelay: { type: Number, required: false, default: 0 },
   closeDelay: { type: Number, required: false, default: 0 }
 });
-const emits = defineEmits(["update:open"]);
+const emits = defineEmits(["close:prevent", "update:open"]);
 const slots = defineSlots();
 const appConfig = useAppConfig();
 const pick = props.mode === "hover" ? reactivePick(props, "defaultOpen", "open", "openDelay", "closeDelay") : reactivePick(props, "defaultOpen", "open", "modal");
@@ -34,11 +34,14 @@ const portalProps = usePortal(toRef(() => props.portal));
 const contentProps = toRef(() => defu(props.content, { side: "bottom", sideOffset: 8, collisionPadding: 8 }));
 const contentEvents = computed(() => {
   if (!props.dismissible) {
-    return {
-      pointerDownOutside: (e) => e.preventDefault(),
-      interactOutside: (e) => e.preventDefault(),
-      escapeKeyDown: (e) => e.preventDefault()
-    };
+    const events = ["pointerDownOutside", "interactOutside", "escapeKeyDown"];
+    return events.reduce((acc, curr) => {
+      acc[curr] = (e) => {
+        e.preventDefault();
+        emits("close:prevent");
+      };
+      return acc;
+    }, {});
   }
   return {};
 });

package/dist/runtime/components/Popover.vue.d.ts

@@ -34,6 +34,7 @@ export interface PopoverProps extends PopoverRootProps, Pick<HoverCardRootProps,
     b24ui?: Popover['slots'];
 }
 export interface PopoverEmits extends PopoverRootEmits {
+    'close:prevent': [];
 }
 export interface PopoverSlots {
     default(props: {
@@ -43,8 +44,10 @@ export interface PopoverSlots {
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
+    "close:prevent": () => any;
 }, string, import("vue").PublicProps, Readonly<PopoverProps> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onClose:prevent"?: (() => any) | undefined;
 }>, {
     mode: "click" | "hover";
     portal: boolean | string | HTMLElement;