@byyuurin/ui 0.0.10 → 0.1.0

package/dist/runtime/components/Select.vue

@@ -1,273 +1,273 @@
-<script lang="ts">
-import type { VariantProps } from '@byyuurin/ui-kit'
-import type { SelectArrowProps, SelectContentEmits, SelectContentProps, SelectRootEmits, SelectRootProps } from 'reka-ui'
-import type { UseComponentIconsProps } from '../composables/useComponentIcons'
-import type { select } from '../theme'
-import type { AcceptableValue, ArrayOrNested, ComponentAttrs, EmitsToProps, GetItemKeys, GetItemValue, GetModelValue, GetModelValueEmits, MaybeArray, NestedItem } from '../types'
-
-interface SelectItemBase {
-  label?: string
-  icon?: string
-  /**
-   * The option type.
-   * @default "option"
-   */
-  type?: 'label' | 'separator' | 'option'
-  value?: AcceptableValue
-  disabled?: boolean
-  [key: string]: any
-}
-
-export type SelectItem = SelectItemBase | AcceptableValue | boolean
-
-export type SelectEmits<T extends ArrayOrNested<SelectItem>, VK extends GetItemKeys<T> | undefined, M extends boolean> = Omit<SelectRootEmits, 'update:modelValue'> & {
-  change: [payload: Event]
-  blur: [payload: FocusEvent]
-  focus: [payload: FocusEvent]
-} & GetModelValueEmits<T, VK, M>
-
-type SlotProps<T extends SelectItem> = (props: { item: T, index: number }) => any
-
-export interface SelectSlots<
-  T extends ArrayOrNested<SelectItem> = ArrayOrNested<SelectItem>,
-  VK extends GetItemKeys<T> | undefined = undefined,
-  M extends boolean = false,
-  I extends NestedItem<T> = NestedItem<T>,
-> {
-  'leading'?: (props: { modelValue?: GetModelValue<T, VK, M>, open: boolean, ui: ComponentAttrs<typeof select>['ui'] }) => any
-  'default'?: (props: { modelValue?: GetModelValue<T, VK, M>, open: boolean }) => any
-  'trailing'?: (props: { modelValue?: GetModelValue<T, VK, M>, open: boolean, ui: ComponentAttrs<typeof select>['ui'] }) => any
-  'item'?: SlotProps<I>
-  'item-leading'?: SlotProps<I>
-  'item-label'?: SlotProps<I>
-  'item-trailing'?: SlotProps<I>
-}
-
-type SelectVariants = VariantProps<typeof select>
-
-export interface SelectProps<
-  T extends ArrayOrNested<SelectItem> = ArrayOrNested<SelectItem>,
-  VK extends GetItemKeys<T> = 'value',
-  M extends boolean = false,
-> extends ComponentAttrs<typeof select>, UseComponentIconsProps, Omit<SelectRootProps<T>, 'dir' | 'multiple' | 'modelValue' | 'defaultValue' | 'by'> {
-  id?: string
-  /** The placeholder text when the select is empty. */
-  placeholder?: string
-  variant?: SelectVariants['variant']
-  size?: SelectVariants['size']
-  /**
-   * The icon displayed to open the menu.
-   * @default app.icons.chevronDown
-   */
-  trailingIcon?: string
-  /**
-   * The icon displayed when an item is selected.
-   * @default app.icons.check
-   */
-  selectedIcon?: string
-  /**
-   * The content of the menu.
-   * @default { side: 'bottom', sideOffset: 8, collisionPadding: 8, position: 'popper' }
-   */
-  content?: Omit<SelectContentProps, 'as' | 'asChild' | 'forceMount'> & Partial<EmitsToProps<SelectContentEmits>>
-  /**
-   * Display an arrow alongside the menu.
-   * @default false
-   */
-  arrow?: boolean | Omit<SelectArrowProps, 'as' | 'asChild'>
-  /**
-   * Render the menu in a portal.
-   * @default true
-   */
-  portal?: boolean
-  /**
-   * When `options` is an array of objects, select the field to use as the value.
-   * @default "value"
-   */
-  valueKey?: VK
-  /**
-   * When `options` is an array of objects, select the field to use as the label.
-   * @default "label"
-   */
-  labelKey?: VK
-  options?: T
-  /** The value of the Select when initially rendered. Use when you do not need to control the state of the Select. */
-  defaultValue?: GetModelValue<T, VK, M>
-  /** The controlled value of the Select. Can be bind as `v-model`. */
-  modelValue?: GetModelValue<T, VK, M>
-  /** Whether multiple options can be selected or not. */
-  multiple?: M & boolean
-  /** Highlight the ring color like a focus state. */
-  highlight?: boolean
-  underline?: boolean
-}
+<script>
+import theme from "#build/ui/select";
 </script>
 
-<script lang="ts" setup generic="T extends ArrayOrNested<SelectItem>, VK extends GetItemKeys<T> = 'value', M extends boolean = false">
-import { reactivePick } from '@vueuse/core'
-import { defu } from 'defu'
-import { SelectArrow, SelectContent, SelectGroup, SelectItem, SelectItemIndicator, SelectItemText, SelectLabel, SelectPortal, SelectRoot, SelectSeparator, SelectTrigger, SelectViewport, useForwardPropsEmits } from 'reka-ui'
-import { computed, toRef } from 'vue'
-import { useButtonGroup } from '../composables/useButtonGroup'
-import { useComponentIcons } from '../composables/useComponentIcons'
-import { useFormItem } from '../composables/useFormItem'
-import { useTheme } from '../composables/useTheme'
-import { compare, get, isArrayOfArray } from '../utils'
-
-defineOptions({
-  inheritAttrs: false,
-})
-
-const props = withDefaults(defineProps<SelectProps<T, VK, M>>(), {
-  valueKey: 'value' as never,
-  labelKey: 'label' as never,
-  portal: true,
-})
-
-const emit = defineEmits<SelectEmits<T, VK, M>>()
-const slots = defineSlots<SelectSlots<T, VK, M>>()
-
-const rootProps = useForwardPropsEmits(reactivePick(props, 'open', 'defaultOpen', 'disabled', 'autocomplete', 'required', 'multiple'), emit)
-const contentProps = toRef(() => defu(props.content, { side: 'bottom', sideOffset: 8, collisionPadding: 8, position: 'popper' }) as SelectContentProps)
-const arrowProps = toRef(() => props.arrow as SelectArrowProps)
-
-const { id, name, size: formItemSize, highlight, disabled, ariaAttrs, emitFormChange, emitFormInput, emitFormBlur, emitFormFocus } = useFormItem<SelectProps<T, VK, M>>(props)
-const { size: buttonGroupSize, orientation } = useButtonGroup(props)
-
-const { theme, generateStyle } = useTheme()
+<script setup>
+import { reactivePick } from "@vueuse/core";
+import { defu } from "defu";
+import { SelectArrow, SelectContent, SelectGroup, SelectItem as RekaSelectItem, SelectItemIndicator, SelectItemText, SelectLabel, SelectPortal, SelectRoot, SelectSeparator, SelectTrigger, useForwardPropsEmits } from "reka-ui";
+import { computed, onMounted, shallowRef, toRef } from "vue";
+import { useAppConfig } from "#imports";
+import { useComponentIcons } from "../composables/useComponentIcons";
+import { useFieldGroup } from "../composables/useFieldGroup";
+import { useFormField } from "../composables/useFormField";
+import { usePortal } from "../composables/usePortal";
+import { get, getDisplayValue, isArrayOfArray } from "../utils";
+import { cv, merge } from "../utils/style";
+import Avatar from "./Avatar.vue";
+import Chip from "./Chip.vue";
+import Icon from "./Icon.vue";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  id: { type: String, required: false },
+  placeholder: { type: String, required: false },
+  variant: { type: null, required: false },
+  size: { type: null, required: false },
+  color: { type: null, required: false },
+  trailingIcon: { type: [String, Object], required: false },
+  selectedIcon: { type: [String, Object], required: false },
+  content: { type: Object, required: false },
+  arrow: { type: [Boolean, Object], required: false },
+  portal: { type: [Boolean, String], required: false, skipCheck: true, default: true },
+  valueKey: { type: null, required: false, default: "value" },
+  labelKey: { type: null, required: false, default: "label" },
+  descriptionKey: { type: null, required: false, default: "description" },
+  items: { type: null, required: false },
+  defaultValue: { type: null, required: false },
+  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 },
+  ui: { type: null, required: false },
+  class: { type: [Object, String, Number, Boolean, null, Array], required: false, skipCheck: true },
+  icon: { type: [String, Object], required: false },
+  avatar: { type: Object, required: false },
+  leading: { type: Boolean, required: false },
+  leadingIcon: { type: [String, Object], required: false },
+  trailing: { type: Boolean, required: false },
+  loading: { type: Boolean, required: false },
+  loadingIcon: { type: [String, Object], required: false },
+  open: { type: Boolean, required: false },
+  defaultOpen: { type: Boolean, required: false },
+  autocomplete: { type: String, required: false },
+  disabled: { type: Boolean, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false }
+});
+const emit = defineEmits(["update:open", "change", "blur", "focus", "update:modelValue"]);
+const slots = defineSlots();
+const rootProps = useForwardPropsEmits(reactivePick(props, "open", "defaultOpen", "disabled", "autocomplete", "required", "multiple"), emit);
+const portalProps = usePortal(toRef(() => props.portal));
+const contentProps = toRef(() => defu(props.content, { side: "bottom", sideOffset: 8, collisionPadding: 8, position: "popper" }));
+const arrowProps = toRef(() => props.arrow);
+const { id, name, size: formFieldSize, color, highlight, disabled, ariaAttrs, emitFormChange, emitFormInput, emitFormBlur, emitFormFocus } = useFormField(props);
+const { size: fieldGroupSize, orientation } = useFieldGroup(props);
+const appConfig = useAppConfig();
 const { isLeading, isTrailing, leadingIconName, trailingIconName } = useComponentIcons(toRef(() => defu(props, {
-  trailingIcon: theme.value.app.icons.chevronDown,
-})))
-
-const style = computed(() => generateStyle('select', {
-  ...props,
-  groupOrientation: orientation.value,
-  size: buttonGroupSize.value || formItemSize.value,
-  highlight: highlight.value,
-  leading: isLeading.value,
-  trailing: isTrailing.value,
-}))
-
-const groups = computed<SelectItem[][]>(
-  () => props.options?.length
-    ? isArrayOfArray(props.options) ? props.options : [props.options]
-    : [],
-)
-
-const items = computed(() => groups.value.flat() as T[])
-
-function displayValue(value?: MaybeArray<GetItemValue<T, VK>>): string {
-  if (props.multiple && Array.isArray(value))
-    return value.map((v) => displayValue(v)).filter(Boolean).join(', ')
-
-  const item = items.value.find((item) => compare(typeof item === 'object' ? get(item as Record<string, any>, props.valueKey as string) : item, value))
-  return (item != null) && (typeof item === 'object' ? get(item, props.labelKey as string) : String(item))
+  trailingIcon: appConfig.ui.icons.chevronDown
+})));
+const ui = computed(() => {
+  const styler = cv(merge(theme, appConfig.ui.select));
+  return styler({
+    ...props,
+    fieldGroup: orientation.value,
+    size: fieldGroupSize.value || formFieldSize.value,
+    color: color.value,
+    highlight: highlight.value,
+    leading: isLeading.value || !!props.avatar || !!slots.leading,
+    trailing: isTrailing.value || !!slots.trailing
+  });
+});
+const groups = computed(
+  () => props.items?.length ? isArrayOfArray(props.items) ? props.items : [props.items] : []
+);
+const items = computed(() => groups.value.flat());
+function displayValue(value) {
+  if (props.multiple && Array.isArray(value)) {
+    const displayedValues = value.map((item) => getDisplayValue(items.value, item, {
+      labelKey: props.labelKey,
+      valueKey: props.valueKey
+    })).filter((v) => v != null && v !== "");
+    return displayedValues.length > 0 ? displayedValues.join(", ") : void 0;
+  }
+  return getDisplayValue(items.value, value, {
+    labelKey: props.labelKey,
+    valueKey: props.valueKey
+  });
 }
-
-function isSelectItem(item: SelectItem): item is SelectItemBase {
-  return typeof item === 'object' && item !== null
+const triggerRef = shallowRef(null);
+function autoFocus() {
+  if (props.autofocus) {
+    triggerRef.value?.$el?.focus({
+      focusVisible: true
+    });
+  }
 }
-
-function onUpdate(value: any) {
-  // @ts-expect-error - 'target' does not exist in type 'EventInit'
-  const event = new Event('change', { target: { value } })
-  emit('change', event)
-  emitFormChange()
-  emitFormInput()
+onMounted(() => {
+  setTimeout(() => autoFocus(), props.autofocusDelay);
+});
+function onUpdate(value) {
+  const event = new Event("change", { target: { value } });
+  emit("change", event);
+  emitFormChange();
+  emitFormInput();
 }
-
-function onUpdateOpen(value: boolean) {
+function onUpdateOpen(value) {
   if (value) {
-    const event = new FocusEvent('focus')
-    emit('focus', event)
-    emitFormFocus()
-  }
-  else {
-    const event = new FocusEvent('blur')
-    emit('blur', event)
-    emitFormBlur()
+    const event = new FocusEvent("focus");
+    emit("focus", event);
+    emitFormFocus();
+  } else {
+    const event = new FocusEvent("blur");
+    emit("blur", event);
+    emitFormBlur();
   }
 }
+function isSelectItem(item) {
+  return typeof item === "object" && item !== null;
+}
+defineExpose({
+  triggerRef
+});
 </script>
 
 <template>
   <SelectRoot
-    v-slot="{ modelValue: innerValue, open }"
-    v-bind="rootProps"
+    v-slot="{ modelValue, open }"
     :name="name"
+    v-bind="rootProps"
+    :default-value="defaultValue"
+    :model-value="modelValue"
     :autocomplete="props.autocomplete"
     :disabled="disabled"
-    :default-value="(props.defaultValue as MaybeArray<AcceptableValue>)"
-    :model-value="(props.modelValue as MaybeArray<AcceptableValue>)"
     @update:model-value="onUpdate"
     @update:open="onUpdateOpen"
   >
-    <SelectTrigger v-bind="{ ...$attrs, ...ariaAttrs, id }" :class="style.base({ class: [props.class, props.ui?.base] })">
-      <span v-if="isLeading || slots.leading" :class="style.leading({ class: props.ui?.leading })">
-        <slot name="leading" :model-value="(innerValue as GetModelValue<T, VK, M>)" :open="open" :ui="props.ui">
-          <span v-if="isLeading && leadingIconName" :class="style.leadingIcon({ class: [leadingIconName, props.ui?.leadingIcon] })"></span>
+    <SelectTrigger
+      ref="triggerRef"
+      v-bind="{ id, ...$attrs, ...ariaAttrs }"
+      :class="ui.base({ class: [props.ui?.base, props.class] })"
+      data-part="base"
+    >
+      <span v-if="isLeading || !!props.avatar || slots.leading" :class="ui.leading({ class: props.ui?.leading })" data-part="leading">
+        <slot name="leading" :model-value="modelValue" :open="open" :ui="ui">
+          <Icon
+            v-if="isLeading && leadingIconName"
+            :name="leadingIconName"
+            :class="ui.leadingIcon({ class: props.ui?.leadingIcon })"
+            data-part="leading-icon"
+          />
+          <Avatar
+            v-else-if="props.avatar"
+            :size="props.ui?.itemLeadingChipSize || ui.itemLeadingAvatarSize()"
+            v-bind="props.avatar"
+            :class="ui.leadingAvatar({ class: props.ui?.leadingAvatar })"
+            data-part="leading-avatar"
+          />
         </slot>
       </span>
 
-      <slot :model-value="(innerValue as GetModelValue<T, VK, M>)" :open="open">
-        <template v-for="displayedModelValue in [displayValue((innerValue as GetModelValue<T, VK, M>))]" :key="displayedModelValue">
-          <span v-if="displayedModelValue" :class="style.value({ class: props.ui?.value })">
+      <slot :model-value="modelValue" :open="open" :ui="ui">
+        <template v-for="displayedModelValue in [displayValue(modelValue)]" :key="displayedModelValue">
+          <span v-if="displayedModelValue != null" :class="ui.value({ class: props.ui?.value })" data-part="value">
             {{ displayedModelValue }}
           </span>
-          <span v-else :class="style.placeholder({ class: props.ui?.placeholder })">
-            {{ placeholder }}&nbsp;
+          <span v-else :class="ui.placeholder({ class: props.ui?.placeholder })" data-part="placeholder">
+            <template v-if="props.placeholder">{{ props.placeholder }}</template>
+            <template v-else>&nbsp;</template>
           </span>
         </template>
       </slot>
 
-      <span v-if="isTrailing || !!slots.trailing" :class="style.trailing({ class: props.ui?.trailing })">
-        <slot name="trailing" :model-value="(innerValue as GetModelValue<T, VK, M>)" :open="open" :ui="props.ui">
-          <span v-if="trailingIconName" :class="style.trailingIcon({ class: [trailingIconName, props.ui?.trailingIcon] })"></span>
+      <span v-if="isTrailing || !!slots.trailing" :class="ui.trailing({ class: props.ui?.trailing })" data-part="trailing">
+        <slot name="trailing" :model-value="modelValue" :open="open" :ui="ui">
+          <Icon v-if="trailingIconName" :name="trailingIconName" :class="ui.trailingIcon({ class: props.ui?.trailingIcon })" data-part="trailing-icon" />
         </slot>
       </span>
     </SelectTrigger>
 
-    <SelectPortal :disabled="!props.portal">
-      <SelectContent v-bind="contentProps" :class="style.content({ class: props.ui?.content })">
-        <SelectViewport :class="style.viewport({ class: props.ui?.viewport })">
-          <SelectGroup v-for="(group, groupIndex) in groups" :key="`group-${groupIndex}`" :class="style.group({ class: props.ui?.group })">
+    <SelectPortal v-bind="portalProps">
+      <SelectContent v-bind="contentProps" :class="ui.content({ class: props.ui?.content })" data-part="content">
+        <slot name="content-top"></slot>
+
+        <div role="presentation" :class="ui.viewport({ class: props.ui?.viewport })" data-part="viewport">
+          <SelectGroup v-for="(group, groupIndex) in groups" :key="`group-${groupIndex}`" :class="ui.group({ class: props.ui?.group })" data-part="group">
             <template v-for="(item, index) in group" :key="`group-${groupIndex}-${index}`">
-              <SelectLabel v-if="isSelectItem(item) && item.type === 'label'" :class="style.label({ class: props.ui?.label })">
-                {{ get(item, props.labelKey as string) }}
+              <SelectLabel v-if="isSelectItem(item) && item.type === 'label'" :class="ui.label({ class: [props.ui?.label, item.ui?.label, item.class] })" data-part="label">
+                {{ get(item, props.labelKey) }}
               </SelectLabel>
-              <SelectSeparator v-else-if="isSelectItem(item) && item.type === 'separator'" :class="style.separator({ class: props.ui?.separator })" />
 
-              <SelectItem
+              <SelectSeparator v-else-if="isSelectItem(item) && item.type === 'separator'" :class="ui.separator({ class: [props.ui?.separator, item.ui?.separator, item.class] })" data-part="separator" />
+
+              <RekaSelectItem
                 v-else
-                :class="style.item({ class: props.ui?.item })"
+                :value="isSelectItem(item) ? get(item, props.valueKey) : item"
                 :disabled="isSelectItem(item) && item.disabled"
-                :value="isSelectItem(item) ? get(item, props.valueKey as string) : item"
+                :class="ui.item({ class: [props.ui?.item, ...isSelectItem(item) ? [item.ui?.item, item.class] : []] })"
+                data-part="item"
+                @select="isSelectItem(item) && item.onSelect?.($event)"
               >
-                <slot name="item" :item="(item as NestedItem<T>)" :index="index">
-                  <slot name="item-leading" :item="(item as NestedItem<T>)" :index="index">
-                    <span v-if="isSelectItem(item) && item.icon" :class="style.itemLeadingIcon({ class: [item.icon, props.ui?.itemLeadingIcon] })"></span>
+                <slot name="item" :item="item" :index="index" :ui="ui">
+                  <slot name="item-leading" :item="item" :index="index" :ui="ui">
+                    <Icon
+                      v-if="isSelectItem(item) && item.icon"
+                      :name="item.icon"
+                      :class="ui.itemLeadingIcon({ class: [props.ui?.itemLeadingIcon, item.ui?.itemLeadingIcon] })"
+                      data-part="item-leading-icon"
+                    />
+                    <Avatar
+                      v-else-if="isSelectItem(item) && item.avatar"
+                      :size="item.ui?.itemLeadingAvatarSize || props.ui?.itemLeadingAvatarSize || ui.itemLeadingAvatarSize()"
+                      v-bind="item.avatar"
+                      :class="ui.itemLeadingAvatar({ class: [props.ui?.leadingAvatar, item.ui?.itemLeadingAvatar] })"
+                      data-part="item-leading-avatar"
+                    />
+                    <Chip
+                      v-else-if="isSelectItem(item) && item.chip"
+                      :size="item.ui?.itemLeadingChipSize || props.ui?.itemLeadingChipSize || ui.itemLeadingChipSize()"
+                      inset
+                      standalone
+                      v-bind="item.chip"
+                      :class="ui.itemLeadingChip({ class: [props.ui?.itemLeadingChip, item.ui?.itemLeadingChip] })"
+                      data-part="item-leading-chip"
+                    />
                   </slot>
 
-                  <SelectItemText :class="style.itemLabel({ class: props.ui?.itemLabel })">
-                    <slot name="item-label" :item="(item as NestedItem<T>)" :index="index">
-                      {{ isSelectItem(item) ? get(item, props.labelKey as string) : item }}
-                    </slot>
-                  </SelectItemText>
+                  <span :class="ui.itemWrapper({ class: [props.ui?.itemWrapper, ...isSelectItem(item) ? [item.ui?.itemWrapper] : []] })" data-part="item-wrapper">
+                    <SelectItemText :class="ui.itemLabel({ class: [props.ui?.itemLabel, isSelectItem(item) && item.ui?.itemLabel] })" data-part="item-label">
+                      <slot name="item-label" :item="item" :index="index">
+                        {{ isSelectItem(item) ? get(item, props.labelKey) : item }}
+                      </slot>
+                    </SelectItemText>
+
+                    <span
+                      v-if="isSelectItem(item) && get(item, props.descriptionKey) || !!slots['item-description']"
+                      :class="ui.itemDescription({ class: [props.ui?.itemDescription, ...isSelectItem(item) ? [item.ui?.itemDescription] : []] })"
+                      data-part="item-description"
+                    >
+                      <slot name="item-description" :item="item" :index="index">
+                        {{ isSelectItem(item) ? get(item, props.descriptionKey) : "" }}
+                      </slot>
+                    </span>
+                  </span>
 
-                  <span :class="style.itemTrailing({ class: props.ui?.itemTrailing })">
-                    <slot name="item-trailing" :item="(item as NestedItem<T>)" :index="index"></slot>
+                  <span :class="ui.itemTrailing({ class: [props.ui?.itemTrailing, isSelectItem(item) && item.ui?.itemTrailing] })" data-part="item-trailing">
+                    <slot name="item-trailing" :item="item" :index="index" :ui="ui"></slot>
 
                     <SelectItemIndicator as-child>
-                      <span :class="style.itemTrailingIcon({ class: [props.selectedIcon || theme.app.icons.check, props.ui?.itemTrailingIcon] })"></span>
+                      <Icon :name="props.selectedIcon || appConfig.ui.icons.check" :class="ui.itemTrailingIcon({ class: [props.ui?.itemTrailingIcon, isSelectItem(item) && item.ui?.itemTrailingIcon] })" data-part="item-trailing-icon" />
                     </SelectItemIndicator>
                   </span>
                 </slot>
-              </SelectItem>
+              </RekaSelectItem>
             </template>
           </SelectGroup>
-        </SelectViewport>
+        </div>
+
+        <slot name="content-bottom"></slot>
 
-        <SelectArrow v-if="!!props.arrow" v-bind="arrowProps" :class="style.arrow({ class: props.ui?.arrow })" />
+        <SelectArrow v-if="props.arrow" v-bind="arrowProps" :class="ui.arrow({ class: props.ui?.arrow })" data-part="arrow" />
       </SelectContent>
     </SelectPortal>
   </SelectRoot>