@byyuurin/ui 0.0.10 → 0.1.0

package/dist/runtime/components/Button.vue

@@ -1,94 +1,166 @@
-<script lang="ts">
-import type { VariantProps } from '@byyuurin/ui-kit'
-import type { UseComponentIconsProps } from '../composables/useComponentIcons'
-import type { button } from '../theme'
-import type { ComponentAttrs } from '../types'
-import type { LinkProps } from './Link.vue'
-
-export interface ButtonSlots {
-  default?: (props?: {}) => any
-  leading?: (props?: {}) => any
-  trailing?: (props?: {}) => any
-}
-
-type ButtonVariants = VariantProps<typeof button>
-
-export interface ButtonProps extends ComponentAttrs<typeof button>, UseComponentIconsProps, Omit<LinkProps, 'raw' | 'custom' | 'underline'> {
-  icon?: string
-  label?: string
-  variant?: ButtonVariants['variant']
-  size?: ButtonVariants['size']
-  loading?: boolean
-  active?: boolean
-  disabled?: boolean
-}
+<script>
+import theme from "#build/ui/button";
 </script>
 
-<script lang="ts" setup>
-import { useForwardProps } from 'reka-ui'
-import { computed } from 'vue'
-import { useButtonGroup } from '../composables/useButtonGroup'
-import { useComponentIcons } from '../composables/useComponentIcons'
-import { useTheme } from '../composables/useTheme'
-import { omit, pickLinkProps } from '../utils'
-import Link from './Link.vue'
-
-const props = withDefaults(defineProps<ButtonProps>(), {
-  variant: 'solid',
-})
-
-const slots = defineSlots<ButtonSlots>()
-
-const { size, orientation } = useButtonGroup(props)
+<script setup>
+import { useForwardProps } from "reka-ui";
+import { computed, shallowRef } from "vue";
+import { useAppConfig } from "#imports";
+import { useComponentIcons } from "../composables/useComponentIcons";
+import { useFieldGroup } from "../composables/useFieldGroup";
+import { injectFormLoading } from "../composables/useFormField";
+import { omit, pickLinkProps } from "../utils";
+import { cv, merge } from "../utils/style";
+import Avatar from "./Avatar.vue";
+import Icon from "./Icon.vue";
+import Link from "./Link.vue";
+import LinkBase from "./LinkBase.vue";
+const props = defineProps({
+  icon: { type: [String, Object], required: false },
+  label: { type: String, required: false },
+  variant: { type: null, required: false },
+  activeVariant: { type: null, required: false },
+  size: { type: null, required: false },
+  color: { type: null, required: false },
+  activeColor: { type: null, required: false },
+  square: { type: Boolean, required: false },
+  block: { type: Boolean, required: false },
+  loadingAuto: { type: Boolean, required: false },
+  onClick: { type: [Function, Array], required: false },
+  ui: { type: null, required: false },
+  class: { type: [Object, String, Number, Boolean, null, Array], required: false, skipCheck: true },
+  avatar: { type: Object, required: false },
+  leading: { type: Boolean, required: false },
+  leadingIcon: { type: [String, Object], required: false },
+  trailing: { type: Boolean, required: false },
+  trailingIcon: { type: [String, Object], required: false },
+  loading: { type: Boolean, required: false },
+  loadingIcon: { type: [String, Object], required: false },
+  as: { type: null, required: false },
+  type: { type: null, required: false },
+  disabled: { type: Boolean, required: false },
+  active: { type: Boolean, required: false },
+  exact: { type: Boolean, required: false },
+  exactQuery: { type: [Boolean, String], required: false },
+  exactHash: { type: Boolean, required: false },
+  inactiveClass: { type: String, required: false },
+  to: { type: null, required: false },
+  href: { type: null, required: false },
+  external: { type: Boolean, required: false },
+  target: { type: [String, Object], required: false },
+  rel: { type: [String, Object], required: false },
+  noRel: { type: Boolean, required: false },
+  prefetchedClass: { type: String, required: false },
+  prefetch: { type: Boolean, required: false },
+  prefetchOn: { type: [String, Object], required: false },
+  noPrefetch: { type: Boolean, required: false },
+  activeClass: { type: String, required: false },
+  exactActiveClass: { type: String, required: false },
+  ariaCurrentValue: { type: String, required: false },
+  viewTransition: { type: Boolean, required: false },
+  replace: { type: Boolean, required: false }
+});
+const slots = defineSlots();
+const linkProps = useForwardProps(pickLinkProps(props));
+const loadingAutoState = shallowRef(false);
+const formLoading = injectFormLoading();
+async function onClickWrapper(event) {
+  loadingAutoState.value = true;
+  const callbacks = Array.isArray(props.onClick) ? props.onClick : [props.onClick];
+  try {
+    await Promise.all(callbacks.map((fn) => fn?.(event)));
+  } finally {
+    loadingAutoState.value = false;
+  }
+}
+const isLoading = computed(() => props.loading || props.loadingAuto && (loadingAutoState.value || formLoading?.value && props.type === "submit"));
+const { size, orientation } = useFieldGroup(props);
 const { isLeading, isTrailing, leadingIconName, trailingIconName } = useComponentIcons(
-  computed(() => ({ ...props, loading: props.loading })),
-)
-
-const linkProps = useForwardProps(pickLinkProps(props))
-
-const { generateStyle } = useTheme()
-
-const style = computed(() => {
-  return generateStyle('button', {
+  computed(() => ({ ...props, loading: isLoading.value }))
+);
+const appConfig = useAppConfig();
+const ui = computed(() => {
+  const uiConfig = {
+    ...appConfig.ui.button,
+    variants: {
+      ...appConfig.ui.button?.variants,
+      active: {
+        true: {
+          base: [appConfig.ui.button?.variants?.active?.true?.base, props.activeClass].filter(Boolean).join(" ")
+        },
+        false: {
+          base: [appConfig.ui.button?.variants?.active?.false?.base, props.inactiveClass].filter(Boolean).join(" ")
+        }
+      }
+    }
+  };
+  const styler = cv(merge(theme, uiConfig));
+  return styler({
     ...props,
+    loading: isLoading.value,
     size: size.value,
-    groupOrientation: orientation.value,
+    fieldGroup: orientation.value,
+    block: props.block,
+    square: props.square || !slots.default && !props.label,
     leading: isLeading.value,
-    trailing: isTrailing.value,
-    class: [
-      props.class,
-      props.active ? props.activeClass : props.inactiveClass,
-      props.disabled ? props.disableClass : undefined,
-    ],
-  })
-})
+    trailing: isTrailing.value
+  });
+});
 </script>
 
 <template>
   <Link
-    :class="style.base({ class: [props.class, props.ui?.base] })"
+    v-slot="{ active, ...slotProps }"
     :type="props.type"
     :disabled="props.disabled || props.loading"
-    v-bind="omit(linkProps, ['type', 'disabled', 'activeClass', 'inactiveClass', 'disableClass'])"
-    raw
+    v-bind="omit(linkProps, ['type', 'disabled', 'onClick'])"
+    data-part="base"
+    custom
   >
-    <slot name="leading">
-      <span
-        v-if="isLeading && leadingIconName"
-        :class="style.leadingIcon({ class: [leadingIconName, props.ui?.leadingIcon] })"
-      ></span>
-    </slot>
-    <span
-      v-if="props.label || slots.default"
-      :class="style.label({ class: props.ui?.label })"
+    <LinkBase
+      v-bind="slotProps"
+      :class="ui.base({
+  class: [props.ui?.base, props.class],
+  active,
+  ...props.active && props.activeVariant ? { variant: props.activeVariant } : {},
+  ...props.active && props.activeColor ? { color: props.activeColor } : {}
+})"
+      @click="onClickWrapper"
     >
-      <slot>{{ label }}</slot>
-    </span>
-    <slot name="trailing">
-      <span
-        v-if="isTrailing && trailingIconName"
-        :class="style.trailingIcon({ class: [trailingIconName, props.ui?.trailingIcon] })"
-      ></span>
-    </slot>
+      <slot name="leading" :ui="ui">
+        <Icon
+          v-if="isLeading && leadingIconName"
+          :name="leadingIconName"
+          :class="ui.leadingIcon({ class: props.ui?.leadingIcon, active })"
+          data-part="leading-icon"
+        />
+        <Avatar
+          v-else-if="props.avatar"
+          :size="props.ui?.leadingAvatarSize || ui.leadingAvatarSize()"
+          v-bind="props.avatar"
+          :class="ui.leadingAvatar({ class: props.ui?.leadingAvatar, active })"
+          data-part="leading-avatar"
+        />
+      </slot>
+
+      <slot :ui="ui">
+        <span
+          v-if="props.label"
+          :class="ui.label({ class: props.ui?.label, active })"
+          data-part="label"
+        >
+          {{ label }}
+        </span>
+      </slot>
+
+      <slot name="trailing" :ui="ui">
+        <Icon
+          v-if="isTrailing && trailingIconName"
+          :name="trailingIconName"
+          :class="ui.trailingIcon({ class: props.ui?.trailingIcon, active })"
+          data-part="trailing-icon"
+        />
+      </slot>
+    </LinkBase>
   </Link>
 </template>

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

@@ -0,0 +1,45 @@
+import type { VariantProps } from '@byyuurin/ui-kit';
+import theme from '#build/ui/button';
+import type { UseComponentIconsProps } from '../composables/useComponentIcons';
+import type { ComponentBaseProps, ComponentStyler, ComponentUIProps, IconProps, LinkProps } from '../types';
+import type { StaticSlot } from '../types/utils';
+type ThemeVariants = VariantProps<typeof theme>;
+export interface ButtonProps extends ComponentBaseProps, UseComponentIconsProps, Omit<LinkProps, 'raw' | 'custom'> {
+    icon?: IconProps['name'];
+    label?: string;
+    /** @default "solid" */
+    variant?: ThemeVariants['variant'];
+    activeVariant?: ThemeVariants['variant'];
+    /** @default "md"  */
+    size?: ThemeVariants['size'];
+    /** @default "primary" */
+    color?: ThemeVariants['color'];
+    activeColor?: ThemeVariants['color'];
+    /** Render the button with equal padding on all sides. */
+    square?: boolean;
+    /** Render the button full width. */
+    block?: boolean;
+    /** Set loading state automatically based on the `@click` promise state */
+    loadingAuto?: boolean;
+    onClick?: ((event: MouseEvent) => void | Promise<void>) | Array<((event: MouseEvent) => void | Promise<void>)>;
+    ui?: ComponentUIProps<typeof theme>;
+}
+export interface ButtonSlots {
+    default: StaticSlot<{
+        ui: ComponentStyler<typeof theme>;
+    }>;
+    leading: StaticSlot<{
+        ui: ComponentStyler<typeof theme>;
+    }>;
+    trailing: StaticSlot<{
+        ui: ComponentStyler<typeof theme>;
+    }>;
+}
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ButtonSlots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Calendar.vue

@@ -1,110 +1,82 @@
-<script lang="ts">
-import type { VariantProps } from '@byyuurin/ui-kit'
-import type { DateValue } from '@internationalized/date'
-import type { CalendarCellTriggerProps, CalendarRootEmits, CalendarRootProps, DateRange, RangeCalendarRootEmits, RangeCalendarRootProps } from 'reka-ui'
-import type { calendar } from '../theme'
-import type { ComponentAttrs } from '../types'
-
-export interface CalendarEmits<R extends boolean, M extends boolean> extends Omit<CalendarRootEmits & RangeCalendarRootEmits, 'update:modelValue'> {
-  'update:modelValue': [date: CalendarModelValue<R, M>]
-}
-
-export interface CalendarSlots {
-  'heading'?: (props: { value: string }) => any
-  'day'?: (props: Pick<CalendarCellTriggerProps, 'day'>) => any
-  'week-day'?: (props: { day: string }) => any
-}
-
-type CalendarVariants = VariantProps<typeof calendar>
-
-type CalendarDefaultValue<R extends boolean = false, M extends boolean = false> = R extends true
-  ? DateRange
-  : M extends true ? DateValue[] : DateValue
-
-type CalendarModelValue<R extends boolean = false, M extends boolean = false> = R extends true
-  ? (DateRange | null)
-  : M extends true
-    ? (DateValue[] | undefined)
-    : (DateValue | undefined)
-
-type _CalendarRootProps = Omit<CalendarRootProps, 'as' | 'asChild' | 'modelValue' | 'defaultValue' | 'dir' | 'locale' | 'calendarLabel' | 'multiple'>
-type _RangeCalendarRootProps = Omit<RangeCalendarRootProps, 'as' | 'asChild' | 'modelValue' | 'defaultValue' | 'dir' | 'locale' | 'calendarLabel' | 'multiple'>
-
-export interface CalendarProps<R extends boolean = false, M extends boolean = false> extends ComponentAttrs<typeof calendar>, _CalendarRootProps, _RangeCalendarRootProps {
-  /**
-   * The icon to use for the next year control.
-   * @default app.icons.chevronDoubleRight
-   */
-  nextYearIcon?: string
-  /**
-   * The icon to use for the next month control.
-   * @default app.icons.chevronRight
-   */
-  nextMonthIcon?: string
-  /**
-   * The icon to use for the previous year control.
-   * @default app.icons.chevronDoubleLeft
-   */
-  prevYearIcon?: string
-  /**
-   * The icon to use for the previous month control.
-   * @default app.icons.chevronLeft
-   */
-  prevMonthIcon?: string
-  /**
-   * @default "md"
-   */
-  size?: CalendarVariants['size']
-  /** Whether or not a range of dates can be selected */
-  range?: R & boolean
-  /** Whether or not multiple dates can be selected */
-  multiple?: M & boolean
-  /** Show month controls */
-  monthControls?: boolean
-  /** Show year controls */
-  yearControls?: boolean
-  defaultValue?: CalendarDefaultValue<R, M>
-  modelValue?: CalendarDefaultValue<R, M>
-}
+<script>
+import theme from "#build/ui/calendar";
 </script>
 
-<script setup lang="ts" generic="R extends boolean, M extends boolean">
-import { reactiveOmit } from '@vueuse/core'
-import { useForwardPropsEmits } from 'reka-ui'
-import { Calendar as BaseCalendar, RangeCalendar } from 'reka-ui/namespaced'
-import { computed } from 'vue'
-import { useLocale } from '../composables/useLocale'
-import { useTheme } from '../composables/useTheme'
-import Button from './Button.vue'
-
-const props = withDefaults(defineProps<CalendarProps<R, M>>(), {
-  fixedWeeks: true,
-  monthControls: true,
-  yearControls: true,
-})
-const emit = defineEmits<CalendarEmits<R, M>>()
-defineSlots<CalendarSlots>()
-
-const rootProps = useForwardPropsEmits(reactiveOmit(props, 'range', 'modelValue', 'defaultValue', 'size', 'monthControls', 'yearControls', 'class', 'ui'), emit)
-
-const { code: locale, dir, t } = useLocale()
-const { theme, generateStyle } = useTheme()
-
-const nextYearIcon = computed(() => props.nextYearIcon || (dir.value === 'rtl' ? theme.value.app.icons.chevronDoubleLeft : theme.value.app.icons.chevronDoubleRight))
-const nextMonthIcon = computed(() => props.nextMonthIcon || (dir.value === 'rtl' ? theme.value.app.icons.chevronLeft : theme.value.app.icons.chevronRight))
-const prevYearIcon = computed(() => props.prevYearIcon || (dir.value === 'rtl' ? theme.value.app.icons.chevronDoubleRight : theme.value.app.icons.chevronDoubleLeft))
-const prevMonthIcon = computed(() => props.prevMonthIcon || (dir.value === 'rtl' ? theme.value.app.icons.chevronRight : theme.value.app.icons.chevronLeft))
-
-function paginateYear(date: DateValue, sign: -1 | 1) {
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { useForwardPropsEmits } from "reka-ui";
+import { Calendar as BaseCalendar, RangeCalendar } from "reka-ui/namespaced";
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { useLocale } from "../composables/useLocale";
+import { cv, merge } from "../utils/style";
+import Button from "./Button.vue";
+const props = defineProps({
+  as: { type: null, required: false },
+  nextYearIcon: { type: [String, Object], required: false },
+  nextYear: { type: Object, required: false },
+  nextMonthIcon: { type: [String, Object], required: false },
+  nextMonth: { type: Object, required: false },
+  prevYearIcon: { type: [String, Object], required: false },
+  prevYear: { type: Object, required: false },
+  prevMonthIcon: { type: [String, Object], required: false },
+  prevMonth: { type: Object, required: false },
+  size: { type: null, required: false },
+  color: { type: null, required: false },
+  variant: { type: null, required: false },
+  range: { type: Boolean, required: false },
+  multiple: { type: Boolean, required: false },
+  monthControls: { type: Boolean, required: false, default: true },
+  yearControls: { type: Boolean, required: false, default: true },
+  defaultValue: { type: null, required: false },
+  modelValue: { type: null, required: false },
+  ui: { type: null, required: false },
+  class: { type: [Object, String, Number, Boolean, null, Array], required: false, skipCheck: true },
+  defaultPlaceholder: { type: null, required: false },
+  placeholder: { type: null, required: false },
+  pagedNavigation: { type: Boolean, required: false },
+  preventDeselect: { type: Boolean, required: false },
+  weekStartsOn: { type: Number, required: false },
+  weekdayFormat: { type: String, required: false },
+  fixedWeeks: { type: Boolean, required: false, default: true },
+  maxValue: { type: null, required: false },
+  minValue: { type: null, required: false },
+  numberOfMonths: { type: Number, required: false, default: 1 },
+  disabled: { type: Boolean, required: false },
+  readonly: { type: Boolean, required: false },
+  initialFocus: { type: Boolean, required: false },
+  isDateDisabled: { type: Function, required: false },
+  isDateUnavailable: { type: Function, required: false },
+  nextPage: { type: Function, required: false },
+  prevPage: { type: Function, required: false },
+  disableDaysOutsideCurrentView: { type: Boolean, required: false },
+  allowNonContiguousRanges: { type: Boolean, required: false },
+  maximumDays: { type: Number, required: false },
+  isDateHighlightable: { type: Function, required: false },
+  fixedDate: { type: String, required: false }
+});
+const emit = defineEmits(["update:modelValue", "update:placeholder", "update:validModelValue", "update:startValue"]);
+defineSlots();
+const rootProps = useForwardPropsEmits(reactiveOmit(props, "range", "modelValue", "defaultValue", "size", "color", "variant", "monthControls", "yearControls", "class", "ui"), emit);
+const { code: locale, dir, t } = useLocale();
+const appConfig = useAppConfig();
+const ui = computed(() => {
+  const styler = cv(merge(theme, appConfig.ui.calendar));
+  return styler({
+    ...props,
+    outsideView: props.numberOfMonths === 1
+  });
+});
+const nextYearIcon = computed(() => props.nextYearIcon || (dir.value === "rtl" ? appConfig.ui.icons.chevronDoubleLeft : appConfig.ui.icons.chevronDoubleRight));
+const nextMonthIcon = computed(() => props.nextMonthIcon || (dir.value === "rtl" ? appConfig.ui.icons.chevronLeft : appConfig.ui.icons.chevronRight));
+const prevYearIcon = computed(() => props.prevYearIcon || (dir.value === "rtl" ? appConfig.ui.icons.chevronDoubleRight : appConfig.ui.icons.chevronDoubleLeft));
+const prevMonthIcon = computed(() => props.prevMonthIcon || (dir.value === "rtl" ? appConfig.ui.icons.chevronRight : appConfig.ui.icons.chevronLeft));
+function paginateYear(date, sign) {
   if (sign === -1)
-    return date.subtract({ years: 1 })
-
-  return date.add({ years: 1 })
+    return date.subtract({ years: 1 });
+  return date.add({ years: 1 });
 }
-
-const Calendar = computed(() => props.range ? RangeCalendar : BaseCalendar)
-
-const style = computed(() => generateStyle('calendar', props))
+const Calendar = computed(() => props.range ? RangeCalendar : BaseCalendar);
 </script>
 
 <template>
@@ -115,66 +87,68 @@ const style = computed(() => generateStyle('calendar', props))
     :default-value="props.defaultValue"
     :locale="locale"
     :dir="dir"
-    :class="style.root({ class: [props.class, props.ui?.root] })"
+    :class="ui.root({ class: [props.class, props.ui?.root] })"
+    data-part="root"
   >
-    <Calendar.Header :class="style.header({ class: props.ui?.header })">
-      <Calendar.Prev v-if="props.yearControls" :prev-page="date => paginateYear(date, -1)" :aria-label="t('calendar.prevYear')" as-child>
-        <Button :icon="prevYearIcon" :size="props.size" variant="ghost" />
+    <Calendar.Header :class="ui.header({ class: props.ui?.header })" data-part="header">
+      <Calendar.Prev v-if="props.yearControls" :prev-page="(date) => paginateYear(date, -1)" :aria-label="t('calendar.prevYear')" as-child>
+        <Button :icon="prevYearIcon" :size="props.size" color="neutral" variant="ghost" v-bind="props.prevYear" />
       </Calendar.Prev>
       <Calendar.Prev v-if="props.monthControls" :aria-label="t('calendar.prevMonth')" as-child>
-        <Button :icon="prevMonthIcon" :size="props.size" variant="ghost" />
+        <Button :icon="prevMonthIcon" :size="props.size" color="neutral" variant="ghost" v-bind="props.prevMonth" />
       </Calendar.Prev>
 
-      <Calendar.Heading v-slot="{ headingValue }" :class="style.heading({ class: props.ui?.heading })">
+      <Calendar.Heading v-slot="{ headingValue }" :class="ui.heading({ class: props.ui?.heading })" data-part="heading">
         <slot name="heading" :value="headingValue">
           {{ headingValue }}
         </slot>
       </Calendar.Heading>
       <Calendar.Next v-if="props.monthControls" :aria-label="t('calendar.nextMonth')" as-child>
-        <Button :icon="nextMonthIcon" :size="props.size" variant="ghost" />
+        <Button :icon="nextMonthIcon" :size="props.size" color="neutral" variant="ghost" v-bind="props.nextMonth" />
       </Calendar.Next>
       <Calendar.Next v-if="props.yearControls" :next-page="(date) => paginateYear(date, 1)" :aria-label="t('calendar.nextYear')" as-child>
-        <Button :icon="nextYearIcon" :size="props.size" variant="ghost" />
+        <Button :icon="nextYearIcon" :size="props.size" color="neutral" variant="ghost" v-bind="props.nextYear" />
       </Calendar.Next>
     </Calendar.Header>
-    <div :class="style.body({ class: props.ui?.body })">
+    <div :class="ui.body({ class: props.ui?.body })" data-part="body">
       <Calendar.Grid
         v-for="month in grid"
         :key="month.value.toString()"
-        :class="style.grid({ class: props.ui?.grid })"
+        :class="ui.grid({ class: props.ui?.grid })"
+        data-part="grid"
       >
         <Calendar.GridHead>
-          <Calendar.GridRow :class="style.gridWeekDaysRow({ class: props.ui?.gridWeekDaysRow })">
-            <Calendar.HeadCell v-for="day in weekDays" :key="day" :class="style.headCell({ class: props.ui?.headCell })">
+          <Calendar.GridRow :class="ui.gridWeekDaysRow({ class: props.ui?.gridWeekDaysRow })" data-part="grid-week-day-row">
+            <Calendar.HeadCell v-for="day in weekDays" :key="day" :class="ui.headCell({ class: props.ui?.headCell })" data-part="head-cell">
               <slot name="week-day" :day="day">
                 {{ day }}
               </slot>
             </Calendar.HeadCell>
           </Calendar.GridRow>
         </Calendar.GridHead>
-        <Calendar.GridBody :class="style.gridBody({ class: props.ui?.gridBody })">
+        <Calendar.GridBody :class="ui.gridBody({ class: props.ui?.gridBody })" data-part="grid-body">
           <Calendar.GridRow
             v-for="(weekDates, index) in month.rows"
             :key="`weekDates-${index}`"
-            :class="style.gridRow({ class: props.ui?.gridRow })"
+            :class="ui.gridRow({ class: props.ui?.gridRow })"
+            data-part="grid-row"
           >
             <Calendar.Cell
               v-for="weekDate in weekDates"
               :key="weekDate.toString()"
               :date="weekDate"
-              :class="style.cell({ class: props.ui?.cell })"
+              :class="ui.cell({ class: props.ui?.cell })"
+              data-part="cell"
             >
               <Calendar.CellTrigger
-                v-slot="{ disabled, unavailable }"
                 :day="weekDate"
                 :month="month.value"
-                as-child
+                :class="ui.cellTrigger({ class: props.ui?.cellTrigger })"
+                data-part="cell-trigger"
               >
-                <div :class="style.cellTrigger({ class: props.ui?.cellTrigger, disabled: disabled || unavailable })">
-                  <slot name="day" :day="weekDate">
-                    {{ weekDate.day }}
-                  </slot>
-                </div>
+                <slot name="day" :day="weekDate">
+                  {{ weekDate.day }}
+                </slot>
               </Calendar.CellTrigger>
             </Calendar.Cell>
           </Calendar.GridRow>