@bitrix24/b24ui-nuxt 0.6.7 → 0.7.0

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

@@ -1,15 +1,15 @@
-import type { NavigationMenuRootProps, NavigationMenuRootEmits, NavigationMenuContentProps, NavigationMenuContentEmits, CollapsibleRootProps } from 'reka-ui';
+import type { NavigationMenuRootProps, NavigationMenuRootEmits, NavigationMenuContentProps, NavigationMenuContentEmits, AccordionRootProps } from 'reka-ui';
 import type { AppConfig } from '@nuxt/schema';
 import theme from '#build/b24ui/navigation-menu';
-import type { AvatarProps, BadgeProps, LinkProps, IconComponent } from '../types';
+import type { AvatarProps, BadgeProps, LinkProps, PopoverProps, TooltipProps, IconComponent } from '../types';
 import type { ArrayOrNested, DynamicSlots, MergeTypes, NestedItem, EmitsToProps, ComponentConfig } from '../types/utils';
 type NavigationMenu = ComponentConfig<typeof theme, AppConfig, 'navigationMenu'>;
-export interface NavigationMenuChildItem extends Omit<NavigationMenuItem, 'type'> {
+export interface NavigationMenuChildItem extends Omit<NavigationMenuItem, 'type' | 'b24ui'> {
     /** Description is only used when `orientation` is `horizontal`. */
     description?: string;
     [key: string]: any;
 }
-export interface NavigationMenuItem extends Omit<LinkProps, 'type' | 'raw' | 'custom'>, Pick<CollapsibleRootProps, 'defaultOpen' | 'open'> {
+export interface NavigationMenuItem extends Omit<LinkProps, 'type' | 'raw' | 'custom'> {
     label?: string;
     /**
      * @IconComponent
@@ -18,30 +18,49 @@ export interface NavigationMenuItem extends Omit<LinkProps, 'type' | 'raw' | 'cu
     avatar?: AvatarProps;
     /**
      * Display a badge on the item.
-     * `{ size: 'sm', color: 'neutral', variant: 'outline' }`{lang="ts-type"}
+     * `{ size: 'sm', color: 'danger', depth: 'dark' }`{lang="ts"}
      */
     badge?: string | number | BadgeProps;
+    /**
+     * Display a tooltip on the item when the menu is collapsed with the label of the item.
+     * This has priority over the global `tooltip` prop.
+     */
+    tooltip?: boolean | TooltipProps;
+    /**
+     * Display a popover on the item when the menu is collapsed with the children list.
+     * This has priority over the global `popover` prop.
+     */
+    popover?: boolean | PopoverProps;
     /**
      * @IconComponent
      */
     trailingIcon?: IconComponent;
     /**
      * The type of the item.
-     * The `label` type only works on `vertical` orientation.
+     * The `label` type is only displayed in `vertical` orientation.
+     * The `trigger` type is used to force the item to be collapsible when its a link in `vertical` orientation.
      * @defaultValue 'link'
      */
-    type?: 'label' | 'link';
+    type?: 'label' | 'trigger' | 'link';
     slot?: string;
+    /**
+     * The value of the item. Avoid using `index` as the value to prevent conflicts in horizontal orientation with Reka UI.
+     * @defaultValue `item-${index}`
+     */
     value?: string;
     children?: NavigationMenuChildItem[];
     /**
      * With orientation=`horizontal` if `true` it will position the dropdown menu correctly
      */
     viewportRtl?: boolean;
+    defaultOpen?: boolean;
+    open?: boolean;
     onSelect?(e: Event): void;
+    class?: any;
+    b24ui?: Pick<NavigationMenu['slots'], 'item' | 'linkLeadingAvatarSize' | 'linkLeadingAvatar' | 'linkLeadingIcon' | 'linkLabel' | 'linkLabelExternalIcon' | 'linkTrailing' | 'linkTrailingBadgeSize' | 'linkTrailingBadge' | 'linkTrailingIcon' | 'label' | 'link' | 'content' | 'childList' | 'childLabel' | 'childItem' | 'childLink' | 'childLinkIcon' | 'childLinkWrapper' | 'childLinkLabel' | 'childLinkLabelExternalIcon' | 'childLinkDescription'>;
     [key: string]: any;
 }
-export interface NavigationMenuProps<T extends ArrayOrNested<NavigationMenuItem> = ArrayOrNested<NavigationMenuItem>> extends Pick<NavigationMenuRootProps, 'modelValue' | 'defaultValue' | 'delayDuration' | 'disableClickTrigger' | 'disableHoverTrigger' | 'skipDelayDuration' | 'disablePointerLeaveClose' | 'unmountOnHide'> {
+export interface NavigationMenuProps<T extends ArrayOrNested<NavigationMenuItem> = ArrayOrNested<NavigationMenuItem>> extends Pick<NavigationMenuRootProps, 'modelValue' | 'defaultValue' | 'delayDuration' | 'disableClickTrigger' | 'disableHoverTrigger' | 'skipDelayDuration' | 'disablePointerLeaveClose' | 'unmountOnHide'>, Pick<AccordionRootProps, 'disabled' | 'type' | 'collapsible'> {
     /**
      * The element or component this component should render as.
      * @defaultValue 'div'
@@ -80,6 +99,18 @@ export interface NavigationMenuProps<T extends ArrayOrNested<NavigationMenuItem>
      * @defaultValue false
      */
     collapsed?: boolean;
+    /**
+     * Display a tooltip on the items when the menu is collapsed with the label of the item.
+     * `{ delayDuration: 0, content: { side: 'right' } }`{lang="ts"}
+     * @defaultValue false
+     */
+    tooltip?: boolean | TooltipProps;
+    /**
+     * Display a popover on the items when the menu is collapsed with the children list.
+     * `{ mode: 'hover', content: { side: 'right', align: 'start', alignOffset: 2 } }`{lang="ts"}
+     * @defaultValue false
+     */
+    popover?: boolean | PopoverProps;
     /** Display a line next to the active item. */
     highlight?: boolean;
     /**

package/dist/runtime/components/OverlayProvider.vue

@@ -1,11 +1,11 @@
 <script setup>
 import { computed } from "vue";
 import { useOverlay } from "../composables/useOverlay";
-const { overlays, unMount, close } = useOverlay();
+const { overlays, unmount, close } = useOverlay();
 const mountedOverlays = computed(() => overlays.filter((overlay) => overlay.isMounted));
 const onAfterLeave = (id) => {
   close(id);
-  unMount(id);
+  unmount(id);
 };
 const onClose = (id, value) => {
   close(id, value);

package/dist/runtime/components/Popover.vue

@@ -58,6 +58,10 @@ const Component = computed(() => props.mode === "hover" ? HoverCard : Popover);
       <slot :open="open" />
     </Component.Trigger>
 
+    <Component.Anchor v-if="'Anchor' in Component && !!slots.anchor" as-child>
+      <slot name="anchor" />
+    </Component.Anchor>
+
     <Component.Portal v-bind="portalProps">
       <Component.Content v-bind="contentProps" :class="b24ui.content({ class: [!slots.default && props.class, props.b24ui?.content] })" v-on="contentEvents">
         <slot name="content" />

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

@@ -41,6 +41,7 @@ export interface PopoverSlots {
         open: boolean;
     }): any;
     content(props?: {}): any;
+    anchor(props?: {}): any;
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
@@ -49,8 +50,8 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PopoverPro
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
     "onClose:prevent"?: (() => any) | undefined;
 }>, {
-    mode: "click" | "hover";
     portal: boolean | string | HTMLElement;
+    mode: "click" | "hover";
     dismissible: boolean;
     openDelay: number;
     closeDelay: number;

package/dist/runtime/components/Progress.vue

@@ -21,13 +21,14 @@ const props = defineProps({
   class: { type: null, required: false },
   b24ui: { type: null, required: false },
   getValueLabel: { type: Function, required: false },
+  getValueText: { type: Function, required: false },
   modelValue: { type: [Number, null], required: false, default: null }
 });
 const emits = defineEmits(["update:modelValue", "update:max"]);
 const slots = defineSlots();
 const { dir } = useLocale();
 const appConfig = useAppConfig();
-const rootProps = useForwardPropsEmits(reactivePick(props, "getValueLabel", "modelValue"), emits);
+const rootProps = useForwardPropsEmits(reactivePick(props, "getValueLabel", "getValueText", "modelValue"), emits);
 const isIndeterminate = computed(() => rootProps.value.modelValue === null);
 const hasSteps = computed(() => Array.isArray(props.max));
 const realMax = computed(() => {
@@ -109,7 +110,7 @@ const b24ui = computed(() => tv({ extend: tv(theme), ...appConfig.b24ui?.progres
 </script>
 
 <template>
-  <Primitive :as="as" :class="b24ui.root({ class: [props.class, props.b24ui?.root] })">
+  <Primitive :as="as" :class="b24ui.root({ class: [props.b24ui?.root, props.class] })">
     <div v-if="!isIndeterminate && (status || !!slots.status)" :class="b24ui.status({ class: props.b24ui?.status })" :style="statusStyle">
       <slot name="status" :percent="percent">
         {{ percent }}%

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

@@ -3,7 +3,7 @@ import type { AppConfig } from '@nuxt/schema';
 import theme from '#build/b24ui/progress';
 import type { ComponentConfig } from '../types/utils';
 type Progress = ComponentConfig<typeof theme, AppConfig, 'progress'>;
-export interface ProgressProps extends Pick<ProgressRootProps, 'getValueLabel' | 'modelValue'> {
+export interface ProgressProps extends Pick<ProgressRootProps, 'getValueLabel' | 'getValueText' | 'modelValue'> {
     /**
      * The element or component this component should render as.
      * @defaultValue 'div'
@@ -61,8 +61,8 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProgressPr
     "onUpdate:max"?: ((value: number) => any) | undefined;
 }>, {
     orientation: Progress["variants"]["orientation"];
-    inverted: boolean;
     modelValue: number | null;
+    inverted: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProgressSlots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/components/RadioGroup.vue

@@ -24,10 +24,10 @@ const props = defineProps({
   indicator: { type: null, required: false },
   class: { type: null, required: false },
   b24ui: { type: null, required: false },
-  defaultValue: { type: [String, Number, Object, null], required: false },
+  defaultValue: { type: null, required: false },
   disabled: { type: Boolean, required: false },
   loop: { type: Boolean, required: false },
-  modelValue: { type: [String, Number, Object, null], required: false },
+  modelValue: { type: null, required: false },
   name: { type: String, required: false },
   required: { type: Boolean, required: false }
 });
@@ -93,7 +93,7 @@ function onUpdate(value) {
     v-bind="rootProps"
     :name="name"
     :disabled="disabled"
-    :class="b24ui.root({ class: [props.class, props.b24ui?.root] })"
+    :class="b24ui.root({ class: [props.b24ui?.root, props.class] })"
     @update:model-value="onUpdate"
   >
     <fieldset :class="b24ui.fieldset({ class: props.b24ui?.fieldset })" v-bind="ariaAttrs">
@@ -102,25 +102,41 @@ function onUpdate(value) {
           {{ legend }}
         </slot>
       </legend>
-      <component :is="variant === 'list' ? 'div' : Label" v-for="item in normalizedItems" :key="item.value" :class="b24ui.item({ class: props.b24ui?.item })">
-        <div :class="b24ui.container({ class: props.b24ui?.container })">
+      <component
+        :is="!variant || variant === 'list' ? 'div' : Label"
+        v-for="item in normalizedItems"
+        :key="item.value"
+        :class="b24ui.item({ class: [props.b24ui?.item, item.b24ui?.item, item.class] })"
+      >
+        <div :class="b24ui.container({ class: [props.b24ui?.container, item.b24ui?.container] })">
           <RadioGroupItem
             :id="item.id"
             :value="item.value"
             :disabled="item.disabled"
-            :class="b24ui.base({ class: props.b24ui?.base, disabled: item.disabled })"
+            :class="b24ui.base({ class: [props.b24ui?.base, item.b24ui?.base], disabled: item.disabled })"
           >
-            <RadioGroupIndicator :class="b24ui.indicator({ class: props.b24ui?.indicator })" />
+            <RadioGroupIndicator :class="b24ui.indicator({ class: [props.b24ui?.indicator, item.b24ui?.indicator] })" />
           </RadioGroupItem>
         </div>
 
-        <div :class="b24ui.wrapper({ class: props.b24ui?.wrapper })">
-          <component :is="variant === 'list' ? Label : 'p'" :class="b24ui.label({ class: props.b24ui?.label })" :for="item.id">
+        <div
+          v-if="item.label || !!slots.label || (item.description || !!slots.description)"
+          :class="b24ui.wrapper({ class: [props.b24ui?.wrapper, item.b24ui?.wrapper] })"
+        >
+          <component
+            :is="!variant || variant === 'list' ? Label : 'p'"
+            v-if="item.label || !!slots.label"
+            :for="item.id"
+            :class="b24ui.label({ class: [props.b24ui?.label, item.b24ui?.label] })"
+          >
             <slot name="label" :item="item" :model-value="modelValue">
               {{ item.label }}
             </slot>
           </component>
-          <p v-if="item.description || !!slots.description" :class="b24ui.description({ class: props.b24ui?.description })">
+          <p
+            v-if="item.description || !!slots.description"
+            :class="b24ui.description({ class: [props.b24ui?.description, item.b24ui?.description] })"
+          >
             <slot name="description" :item="item" :model-value="modelValue">
               {{ item.description }}
             </slot>

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

@@ -8,7 +8,9 @@ export type RadioGroupItem = {
     label?: string;
     description?: string;
     disabled?: boolean;
-    value?: string;
+    value?: RadioGroupValue;
+    class?: any;
+    b24ui?: Pick<RadioGroup['slots'], 'item' | 'container' | 'base' | 'indicator' | 'wrapper' | 'label' | 'description'>;
     [key: string]: any;
 } | RadioGroupValue;
 export interface RadioGroupProps<T extends RadioGroupItem = RadioGroupItem> extends Pick<RadioGroupRootProps, 'defaultValue' | 'disabled' | 'loop' | 'modelValue' | 'name' | 'required'> {

package/dist/runtime/components/Range.vue

@@ -26,7 +26,7 @@ const props = defineProps({
   minStepsBetweenThumbs: { type: Number, required: false }
 });
 const emits = defineEmits(["update:modelValue", "change"]);
-const modelValue = defineModel({ type: [Number, Array] });
+const modelValue = defineModel({ type: null });
 const appConfig = useAppConfig();
 const rootProps = useForwardPropsEmits(reactivePick(props, "as", "orientation", "min", "max", "step", "minStepsBetweenThumbs", "inverted"), emits);
 const { id, emitFormChange, emitFormInput, size, color, name, disabled, ariaAttrs } = useFormField(props);
@@ -68,7 +68,7 @@ function onChange(value) {
     v-model="rangeValue"
     :name="name"
     :disabled="disabled"
-    :class="b24ui.root({ class: [props.class, props.b24ui?.root] })"
+    :class="b24ui.root({ class: [props.b24ui?.root, props.class] })"
     :default-value="defaultRangeValue"
     @update:model-value="emitFormInput()"
     @value-commit="onChange"

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

@@ -29,26 +29,25 @@ export interface RangeProps extends Pick<SliderRootProps, 'name' | 'disabled' |
     class?: any;
     b24ui?: Range['slots'];
 }
-export interface RangeEmits {
-    (e: 'update:modelValue', payload: number | number[]): void;
+export interface RangeEmits<T extends number | number[] = number | number[]> {
+    (e: 'update:modelValue', payload: T): void;
     (e: 'change', payload: Event): void;
 }
-declare const _default: import("vue").DefineComponent<RangeProps & {
-    modelValue?: number | number[];
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: number | number[] | undefined) => any;
-} & {
-    change: (payload: Event) => any;
-    "update:modelValue": (payload: number | number[]) => any;
-}, string, import("vue").PublicProps, Readonly<RangeProps & {
-    modelValue?: number | number[];
-}> & Readonly<{
-    onChange?: ((payload: Event) => any) | undefined;
-    "onUpdate:modelValue"?: ((payload: number | number[]) => any) | undefined;
-}>, {
-    orientation: "horizontal" | "vertical";
-    step: number;
-    max: number;
-    min: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: <T extends number | number[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChange?: ((payload: Event) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((payload: T) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onChange" | "onUpdate:modelValue"> & (RangeProps & {
+        modelValue?: T;
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: RangeEmits<T> & ((evt: "update:modelValue", value: T | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
 export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/Select.vue

@@ -3,8 +3,8 @@ import theme from "#build/b24ui/select";
 </script>
 
 <script setup>
-import { computed, toRef } from "vue";
-import { Primitive, SelectRoot, SelectArrow, SelectTrigger, SelectPortal, SelectContent, SelectViewport, SelectScrollUpButton, SelectScrollDownButton, SelectLabel, SelectGroup, SelectItem, SelectItemIndicator, SelectItemText, SelectSeparator, useForwardPropsEmits } from "reka-ui";
+import { ref, computed, onMounted, toRef } from "vue";
+import { Primitive, SelectRoot, SelectArrow, SelectTrigger, SelectPortal, SelectContent, SelectLabel, SelectGroup, SelectItem, SelectItemIndicator, SelectItemText, SelectSeparator, useForwardPropsEmits } from "reka-ui";
 import { defu } from "defu";
 import { reactivePick } from "@vueuse/core";
 import { useAppConfig } from "#imports";
@@ -41,6 +41,8 @@ const props = defineProps({
   modelValue: { type: null, required: false },
   multiple: { type: Boolean, required: false },
   highlight: { type: Boolean, required: false },
+  autofocus: { type: Boolean, required: false },
+  autofocusDelay: { type: Number, required: false, default: 0 },
   class: { type: null, required: false },
   b24ui: { type: null, required: false },
   open: { type: Boolean, required: false },
@@ -91,11 +93,25 @@ const groups = computed(
 const items = computed(() => groups.value.flatMap((group) => group));
 function displayValue(value) {
   if (props.multiple && Array.isArray(value)) {
-    return value.map((v) => displayValue(v)).filter(Boolean).join(", ");
+    const values = value.map((v) => displayValue(v)).filter(Boolean);
+    return values?.length ? values.join(", ") : void 0;
   }
   const item = items.value.find((item2) => compare(typeof item2 === "object" ? get(item2, props.valueKey) : item2, value));
   return item && (typeof item === "object" ? get(item, props.labelKey) : item);
 }
+const triggerRef = ref(null);
+function autoFocus() {
+  if (props.autofocus) {
+    triggerRef.value?.$el?.focus({
+      focusVisible: true
+    });
+  }
+}
+onMounted(() => {
+  setTimeout(() => {
+    autoFocus();
+  }, props.autofocusDelay);
+});
 function onUpdate(value) {
   const event = new Event("change", { target: { value } });
   emits("change", event);
@@ -116,6 +132,9 @@ function onUpdateOpen(value) {
 function isSelectItem(item) {
   return typeof item === "object" && item !== null;
 }
+defineExpose({
+  triggerRef
+});
 </script>
 
 <template>
@@ -131,7 +150,12 @@ function isSelectItem(item) {
       @update:model-value="onUpdate"
       @update:open="onUpdateOpen"
     >
-      <SelectTrigger :id="id" :class="b24ui.base({ class: [props.class, props.b24ui?.base] })" v-bind="{ ...$attrs, ...ariaAttrs }">
+      <SelectTrigger
+        :id="id"
+        ref="triggerRef"
+        :class="b24ui.base({ class: [props.b24ui?.base, props.class] })"
+        v-bind="{ ...$attrs, ...ariaAttrs }"
+      >
         <div v-if="isTag" :class="b24ui.tag({ class: props.b24ui?.tag })">
           {{ props.tag }}
         </div>
@@ -149,11 +173,17 @@ function isSelectItem(item) {
 
         <slot :model-value="modelValue" :open="open">
           <template v-for="displayedModelValue in [displayValue(modelValue)]" :key="displayedModelValue">
-            <span v-if="displayedModelValue" :class="b24ui.value({ class: props.b24ui?.value })">
+            <span
+              v-if="displayedModelValue !== void 0 && displayedModelValue !== null"
+              :class="b24ui.value({ class: props.b24ui?.value })"
+            >
               {{ displayedModelValue }}
             </span>
-            <span v-else :class="b24ui.placeholder({ class: props.b24ui?.placeholder })">
-              {{ placeholder ?? '\xA0' }}
+            <span
+              v-else
+              :class="b24ui.placeholder({ class: props.b24ui?.placeholder })"
+            >
+              {{ placeholder ?? "\xA0" }}
             </span>
           </template>
         </slot>
@@ -173,24 +203,21 @@ function isSelectItem(item) {
         <SelectContent :class="b24ui.content({ class: props.b24ui?.content })" v-bind="contentProps">
           <slot name="content-top" />
 
-          <SelectScrollUpButton :class="b24ui.scrollUpDownButton({ class: props.b24ui?.scrollUpDownButton })">
-            <Component
-              :is="icons.chevronUp"
-              :class="b24ui.scrollUpDownButtonIcon({ class: props.b24ui?.scrollUpDownButtonIcon })"
-            />
-          </SelectScrollUpButton>
-          <SelectViewport :class="b24ui.viewport({ class: props.b24ui?.viewport })">
+          <div
+            role="presentation"
+            :class="b24ui.viewport({ class: props.b24ui?.viewport })"
+          >
             <SelectGroup v-for="(group, groupIndex) in groups" :key="`group-${groupIndex}`" :class="b24ui.group({ class: props.b24ui?.group })">
               <template v-for="(item, index) in group" :key="`group-${groupIndex}-${index}`">
-                <SelectLabel v-if="isSelectItem(item) && item.type === 'label'" :class="b24ui.label({ class: props.b24ui?.label })">
+                <SelectLabel v-if="isSelectItem(item) && item.type === 'label'" :class="b24ui.label({ class: [props.b24ui?.label, item.b24ui?.label, item.class] })">
                   {{ get(item, props.labelKey) }}
                 </SelectLabel>
 
-                <SelectSeparator v-else-if="isSelectItem(item) && item.type === 'separator'" :class="b24ui.separator({ class: props.b24ui?.separator })" />
+                <SelectSeparator v-else-if="isSelectItem(item) && item.type === 'separator'" :class="b24ui.separator({ class: [props.b24ui?.separator, item.b24ui?.separator, item.class] })" />
 
                 <SelectItem
                   v-else
-                  :class="b24ui.item({ class: props.b24ui?.item, colorItem: isSelectItem(item) ? item?.color : void 0 })"
+                  :class="b24ui.item({ class: [props.b24ui?.item, isSelectItem(item) && item.b24ui?.item, isSelectItem(item) && item.class], colorItem: isSelectItem(item) && item?.color || void 0 })"
                   :disabled="isSelectItem(item) && item.disabled"
                   :value="isSelectItem(item) ? get(item, props.valueKey) : item"
                   @select="isSelectItem(item) && item.onSelect?.($event)"
@@ -200,32 +227,37 @@ function isSelectItem(item) {
                       <Component
                         :is="item.icon"
                         v-if="isSelectItem(item) && item.icon"
-                        :class="b24ui.itemLeadingIcon({ class: props.b24ui?.itemLeadingIcon, colorItem: item?.color })"
+                        :class="b24ui.itemLeadingIcon({ class: [props.b24ui?.itemLeadingIcon, item.b24ui?.itemLeadingIcon], colorItem: item?.color })"
+                      />
+                      <B24Avatar
+                        v-else-if="isSelectItem(item) && item.avatar"
+                        :size="item.b24ui?.itemLeadingAvatarSize || props.b24ui?.itemLeadingAvatarSize || b24ui.itemLeadingAvatarSize()"
+                        v-bind="item.avatar"
+                        :class="b24ui.itemLeadingAvatar({ class: [props.b24ui?.itemLeadingAvatar, item.b24ui?.itemLeadingAvatar], colorItem: item?.color })"
                       />
-                      <B24Avatar v-else-if="isSelectItem(item) && item.avatar" :size="props.b24ui?.itemLeadingAvatarSize || b24ui.itemLeadingAvatarSize()" v-bind="item.avatar" :class="b24ui.itemLeadingAvatar({ class: props.b24ui?.itemLeadingAvatar, colorItem: item?.color })" />
                       <B24Chip
                         v-else-if="isSelectItem(item) && item.chip"
-                        :size="props.b24ui?.itemLeadingChipSize || b24ui.itemLeadingChipSize()"
+                        :size="item.b24ui?.itemLeadingChipSize || props.b24ui?.itemLeadingChipSize || b24ui.itemLeadingChipSize()"
                         inset
                         standalone
                         v-bind="item.chip"
-                        :class="b24ui.itemLeadingChip({ class: props.b24ui?.itemLeadingChip, colorItem: item?.color })"
+                        :class="b24ui.itemLeadingChip({ class: [props.b24ui?.itemLeadingChip, item.b24ui?.itemLeadingChip], colorItem: item?.color })"
                       />
                     </slot>
 
-                    <SelectItemText :class="b24ui.itemLabel({ class: props.b24ui?.itemLabel })">
+                    <SelectItemText :class="b24ui.itemLabel({ class: [props.b24ui?.itemLabel, isSelectItem(item) && item.b24ui?.itemLabel] })">
                       <slot name="item-label" :item="item" :index="index">
                         {{ isSelectItem(item) ? get(item, props.labelKey) : item }}
                       </slot>
                     </SelectItemText>
 
-                    <span :class="b24ui.itemTrailing({ class: props.b24ui?.itemTrailing, colorItem: isSelectItem(item) ? item?.color : void 0 })">
+                    <span :class="b24ui.itemTrailing({ class: [props.b24ui?.itemTrailing, isSelectItem(item) && item.b24ui?.itemTrailing], colorItem: isSelectItem(item) && item?.color || void 0 })">
                       <slot name="item-trailing" :item="item" :index="index" />
 
                       <SelectItemIndicator as-child>
                         <Component
                           :is="selectedIcon || icons.check"
-                          :class="b24ui.itemTrailingIcon({ class: props.b24ui?.itemTrailingIcon, colorItem: isSelectItem(item) ? item?.color : void 0 })"
+                          :class="b24ui.itemTrailingIcon({ class: [props.b24ui?.itemTrailingIcon, isSelectItem(item) && item.b24ui?.itemTrailingIcon], colorItem: isSelectItem(item) && item?.color || void 0 })"
                         />
                       </SelectItemIndicator>
                     </span>
@@ -233,13 +265,7 @@ function isSelectItem(item) {
                 </SelectItem>
               </template>
             </SelectGroup>
-          </SelectViewport>
-          <SelectScrollDownButton :class="b24ui.scrollUpDownButton({ class: props.b24ui?.scrollUpDownButton })">
-            <Component
-              :is="icons.chevronDown"
-              :class="b24ui.scrollUpDownButtonIcon({ class: props.b24ui?.scrollUpDownButtonIcon })"
-            />
-          </SelectScrollDownButton>
+          </div>
 
           <slot name="content-bottom" />