@una-ui/nuxt 0.52.1 → 0.53.0

package/dist/runtime/components/forms/radio-group/RadioGroupItem.vue

@@ -1,54 +1,60 @@
-<script setup lang="ts">
-import type { NRadioGroupItemProps } from '../../../types'
-import { reactivePick } from '@vueuse/core'
+<script setup>
+import { reactivePick } from "@vueuse/core";
 import {
   RadioGroupIndicator,
   RadioGroupItem,
-  useForwardProps,
-} from 'reka-ui'
-import { cn, randomId } from '../../../utils'
-import Icon from '../../elements/Icon.vue'
-import Label from '../../elements/Label.vue'
-
+  useForwardProps
+} from "reka-ui";
+import { cn, randomId } from "../../../utils";
+import Icon from "../../elements/Icon.vue";
+import Label from "../../elements/Label.vue";
 defineOptions({
-  inheritAttrs: false,
-})
-
-const props = withDefaults(defineProps<NRadioGroupItemProps>(), {
-  icon: 'radio-group-indicator-icon',
-  radioGroup: 'primary',
-  size: 'md',
-  square: '1em',
-})
-
-const id = props.id || randomId('radio-group')
-
+  inheritAttrs: false
+});
+const props = defineProps({
+  label: { type: String, required: false },
+  radioGroup: { type: null, required: false, default: "primary" },
+  description: { type: String, required: false },
+  una: { type: Object, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false, default: "md" },
+  square: { type: null, required: false, default: "1em" },
+  rounded: { type: null, required: false },
+  icon: { type: null, required: false, default: "radio-group-indicator-icon" },
+  id: { type: String, required: false },
+  value: { type: [String, Number, Object, null], required: false },
+  disabled: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false }
+});
+const id = props.id || randomId("radio-group");
 const delegatedProps = reactivePick(props, [
-  'as',
-  'disabled',
-  'id',
-  'name',
-  'required',
-  'value',
-])
-
-const forwardedProps = useForwardProps(delegatedProps)
+  "as",
+  "disabled",
+  "id",
+  "name",
+  "required",
+  "value"
+]);
+const forwardedProps = useForwardProps(delegatedProps);
 </script>
 
 <template>
   <div
     :class="cn(
-      'radio-group-item-root',
-      una?.radioGroupItemRoot,
-    )"
+  'radio-group-item-root',
+  una?.radioGroupItemRoot
+)"
     :size
     :radio-group="radioGroup"
   >
     <div
       :class="cn(
-        'radio-group-item-wrapper',
-        una?.radioGroupItemWrapper,
-      )"
+  'radio-group-item-wrapper',
+  una?.radioGroupItemWrapper
+)"
     >
       <RadioGroupItem
         as-child
@@ -57,28 +63,28 @@ const forwardedProps = useForwardProps(delegatedProps)
         <button
           :id
           :class="
-            cn(
-              'radio-group-item',
-              una?.radioGroupItem,
-              props.class,
-            )
-          "
+  cn(
+    'radio-group-item',
+    una?.radioGroupItem,
+    props.class
+  )
+"
           :square
           :rounded
         >
           <RadioGroupIndicator
             :class="cn(
-              'radio-group-indicator',
-              una?.radioGroupIndicator,
-            )"
+  'radio-group-indicator',
+  una?.radioGroupIndicator
+)"
           >
             <slot name="icon">
               <Icon
                 :name="icon"
                 :class="cn(
-                  'radio-group-indicator-icon-base',
-                  una?.radioGroupIndicatorIcon,
-                )"
+  'radio-group-indicator-icon-base',
+  una?.radioGroupIndicatorIcon
+)"
               />
             </slot>
           </RadioGroupIndicator>
@@ -89,9 +95,9 @@ const forwardedProps = useForwardProps(delegatedProps)
         v-if="props.label || $slots.default"
         :for="props.id ?? id"
         :class="cn(
-          'radio-group-item-label',
-          una?.radioGroupItemLabel,
-        )"
+  'radio-group-item-label',
+  una?.radioGroupItemLabel
+)"
       >
         <slot>
           {{ label }}
@@ -102,9 +108,9 @@ const forwardedProps = useForwardProps(delegatedProps)
     <p
       v-if="description || $slots.description"
       :class="cn(
-        'radio-group-item-description',
-        una?.radioGroupItemDescription,
-      )"
+  'radio-group-item-description',
+  una?.radioGroupItemDescription
+)"
     >
       <slot name="description">
         {{ description }}

package/dist/runtime/components/forms/radio-group/RadioGroupItem.vue.d.ts

@@ -0,0 +1,22 @@
+import type { NRadioGroupItemProps } from '../../../types/index.js';
+declare var __VLS_9: {}, __VLS_17: {}, __VLS_19: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_9) => any;
+} & {
+    default?: (props: typeof __VLS_17) => any;
+} & {
+    description?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NRadioGroupItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NRadioGroupItemProps> & Readonly<{}>, {
+    size: import("vue").HTMLAttributes["class"];
+    icon: import("vue").HTMLAttributes["class"];
+    square: import("vue").HTMLAttributes["class"];
+    radioGroup: import("vue").HTMLAttributes["class"];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/forms/select/Select.vue

@@ -1,69 +1,87 @@
-<script lang="ts">
-import type { AcceptableValue, SelectRootEmits } from 'reka-ui'
-import type { NSelectProps, SelectGroup as SelectGroupType } from '../../../types'
-import { computed } from 'vue'
+<script>
+import { computed } from "vue";
 </script>
 
-<script setup lang="ts" generic="T extends AcceptableValue">
-import { SelectRoot, useForwardPropsEmits } from 'reka-ui'
-import { cn, isEqualObject } from '../../../utils'
-import SelectContent from './SelectContent.vue'
-import SelectGroup from './SelectGroup.vue'
-import SelectItem from './SelectItem.vue'
-import SelectLabel from './SelectLabel.vue'
-import SelectSeparator from './SelectSeparator.vue'
-import SelectTrigger from './SelectTrigger.vue'
-import SelectValue from './SelectValue.vue'
-
-const props = withDefaults(defineProps<NSelectProps<T>>(), {
-  size: 'sm',
-})
-
-const emits = defineEmits<SelectRootEmits<T>>()
-
-// Check if items are grouped
+<script setup>
+import { SelectRoot, useForwardPropsEmits } from "reka-ui";
+import { cn, isEqualObject } from "../../../utils";
+import SelectContent from "./SelectContent.vue";
+import SelectGroup from "./SelectGroup.vue";
+import SelectItem from "./SelectItem.vue";
+import SelectLabel from "./SelectLabel.vue";
+import SelectSeparator from "./SelectSeparator.vue";
+import SelectTrigger from "./SelectTrigger.vue";
+import SelectValue from "./SelectValue.vue";
+const props = defineProps({
+  items: { type: Array, required: true },
+  itemKey: { type: null, required: false },
+  valueKey: { type: null, required: false },
+  label: { type: String, required: false },
+  groupSeparator: { type: Boolean, required: false },
+  _selectScrollUpButton: { type: Object, required: false },
+  _selectItemText: { type: Object, required: false },
+  _selectScrollDownButton: { type: Object, required: false },
+  _selectGroup: { type: Object, required: false },
+  _selectSeparator: { type: Object, required: false },
+  _selectContent: { type: Object, required: false },
+  _selectValue: { type: Object, required: false },
+  _selectTrigger: { type: Object, required: false },
+  _selectItem: { type: Object, required: false },
+  _selectLabel: { type: Object, required: false },
+  una: { type: Object, required: false },
+  open: { type: Boolean, required: false },
+  defaultOpen: { type: Boolean, required: false },
+  defaultValue: { type: null, required: false },
+  modelValue: { type: null, required: false },
+  by: { type: [String, Function], required: false },
+  dir: { type: String, required: false },
+  multiple: { type: Boolean, required: false },
+  autocomplete: { type: String, required: false },
+  disabled: { type: Boolean, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false, default: "sm" },
+  placeholder: { type: String, required: false },
+  selectItem: { type: null, required: false },
+  status: { type: String, required: false },
+  select: { type: String, required: false },
+  id: { type: String, required: false }
+});
+const emits = defineEmits(["update:modelValue", "update:open"]);
 const hasGroups = computed(() => {
-  return Array.isArray(props.items) && props.items.length > 0
-    && typeof props.items[0] === 'object' && 'items' in (props.items[0] as any)
-})
-
-const forwarded = useForwardPropsEmits(props, emits)
-
-function formatSelectedValue(value: unknown) {
-  if (!value || (Array.isArray(value) && value.length === 0))
-    return null
-
+  return Array.isArray(props.items) && props.items.length > 0 && typeof props.items[0] === "object" && "items" in props.items[0];
+});
+const forwarded = useForwardPropsEmits(props, emits);
+function formatSelectedValue(value) {
+  if (!value || Array.isArray(value) && value.length === 0)
+    return null;
   if (props.multiple && Array.isArray(value)) {
     return value.map((val) => {
-      if (props.valueKey && typeof val === 'object') {
-        return (val as Record<string, any>)[props.valueKey as string]
+      if (props.valueKey && typeof val === "object") {
+        return val[props.valueKey];
       }
-      return val
-    }).join(', ')
+      return val;
+    }).join(", ");
   }
-
-  if (props.valueKey && typeof value === 'object') {
-    return (value as Record<string, any>)[props.valueKey as string]
+  if (props.valueKey && typeof value === "object") {
+    return value[props.valueKey];
   }
-
-  return value
+  return value;
 }
-
-function isItemSelected(item: unknown, modelValue: unknown) {
+function isItemSelected(item, modelValue) {
   if (!modelValue)
-    return false
-
+    return false;
   if (props.multiple && Array.isArray(modelValue)) {
     return modelValue.some((val) => {
-      const valObj = typeof val === 'object' && val ? val : { value: val }
-      const itemObj = typeof item === 'object' && item ? item : { value: item }
-      return isEqualObject(valObj, itemObj)
-    })
+      const valObj = typeof val === "object" && val ? val : { value: val };
+      const itemObj2 = typeof item === "object" && item ? item : { value: item };
+      return isEqualObject(valObj, itemObj2);
+    });
   }
-
-  const modelObj = typeof modelValue === 'object' && modelValue ? modelValue : { value: modelValue }
-  const itemObj = typeof item === 'object' && item ? item : { value: item }
-  return isEqualObject(modelObj, itemObj)
+  const modelObj = typeof modelValue === "object" && modelValue ? modelValue : { value: modelValue };
+  const itemObj = typeof item === "object" && item ? item : { value: item };
+  return isEqualObject(modelObj, itemObj);
 }
 </script>
 
@@ -71,9 +89,9 @@ function isItemSelected(item: unknown, modelValue: unknown) {
   <SelectRoot
     v-slot="{ modelValue, open }"
     :class="cn(
-      props.una?.select,
-      props.class,
-    )"
+  props.una?.select,
+  props.class
+)"
     v-bind="forwarded"
   >
     <slot :model-value :open>
@@ -105,10 +123,10 @@ function isItemSelected(item: unknown, modelValue: unknown) {
       <SelectContent
         :size
         v-bind="{
-          ..._selectContent,
-          _selectScrollDownButton,
-          _selectScrollUpButton,
-        }"
+  ..._selectContent,
+  _selectScrollDownButton,
+  _selectScrollUpButton
+}"
         :una
       >
         <slot name="content" :items="items">
@@ -136,7 +154,7 @@ function isItemSelected(item: unknown, modelValue: unknown) {
                 :una
               >
                 <slot name="item" :item="item">
-                  {{ props.itemKey && item ? (item as any)[props.itemKey] : item }}
+                  {{ props.itemKey && item ? item[props.itemKey] : item }}
                 </slot>
                 <template #indicator>
                   <slot name="indicator" :item="item" />
@@ -147,7 +165,7 @@ function isItemSelected(item: unknown, modelValue: unknown) {
 
           <template v-if="hasGroups">
             <SelectGroup
-              v-for="(group, i) in items as SelectGroupType<T>[]"
+              v-for="(group, i) in items"
               :key="i"
               v-bind="props._selectGroup"
               :una
@@ -183,7 +201,7 @@ function isItemSelected(item: unknown, modelValue: unknown) {
                     :una
                   >
                     <slot name="item" :item="item">
-                      {{ props.itemKey ? (item as any)[props.itemKey] : item }}
+                      {{ props.itemKey ? item[props.itemKey] : item }}
                     </slot>
                     <template #indicator>
                       <slot name="indicator" :item="item" />

package/dist/runtime/components/forms/select/Select.vue.d.ts

@@ -0,0 +1,72 @@
+import type { AcceptableValue } from 'reka-ui';
+import type { NSelectProps, SelectGroup as SelectGroupType } from '../../../types/index.js';
+declare const _default: <T extends AcceptableValue>(__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 "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        readonly "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:open"> & NSelectProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            modelValue: AcceptableValue | AcceptableValue[] | undefined;
+            open: boolean;
+        }) => any;
+    } & {
+        'trigger-wrapper'?: (props: {
+            modelValue: AcceptableValue | AcceptableValue[] | undefined;
+            open: boolean;
+        }) => any;
+    } & {
+        trigger?: (props: {
+            modelValue: AcceptableValue | AcceptableValue[] | undefined;
+            open: boolean;
+        }) => any;
+    } & {
+        value?: (props: {
+            modelValue: AcceptableValue | AcceptableValue[] | undefined;
+            open: boolean;
+        }) => any;
+    } & {
+        content?: (props: {
+            items: T[] | SelectGroupType<T>[];
+        }) => any;
+    } & {
+        label?: (props: {
+            label: string;
+        }) => any;
+    } & {
+        item?: (props: {
+            item: T | SelectGroupType<T>;
+        }) => any;
+    } & {
+        indicator?: (props: {
+            item: T | SelectGroupType<T>;
+        }) => any;
+    } & {
+        group?: (props: {
+            items: SelectGroupType<T>;
+        }) => any;
+    } & {
+        label?: (props: {
+            label: string;
+        }) => any;
+    } & {
+        item?: (props: {
+            item: T;
+        }) => any;
+    } & {
+        indicator?: (props: {
+            item: T;
+        }) => any;
+    } & {
+        default?: (props: {}) => any;
+    };
+    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "update:open", value: boolean) => 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/forms/select/SelectContent.vue

@@ -1,58 +1,75 @@
-<script setup lang="ts">
-import type { SelectContentEmits } from 'reka-ui'
-import type { NSelectContentProps } from '../../../types'
+<script setup>
 import {
   SelectContent,
   SelectPortal,
   SelectViewport,
-  useForwardPropsEmits,
-} from 'reka-ui'
-import { computed } from 'vue'
-import { cn } from '../../../utils'
-import SelectScrollDownButton from './SelectScrollDownButton.vue'
-import SelectScrollUpButton from './SelectScrollUpButton.vue'
-
+  useForwardPropsEmits
+} from "reka-ui";
+import { computed } from "vue";
+import { cn } from "../../../utils";
+import SelectScrollDownButton from "./SelectScrollDownButton.vue";
+import SelectScrollUpButton from "./SelectScrollUpButton.vue";
 defineOptions({
-  inheritAttrs: false,
-})
-
-const props = withDefaults(
-  defineProps<NSelectContentProps>(),
-  {
-    position: 'popper',
-  },
-)
-const emits = defineEmits<SelectContentEmits>()
-
+  inheritAttrs: false
+});
+const props = defineProps({
+  _selectScrollDownButton: { type: Object, required: false },
+  _selectScrollUpButton: { type: Object, required: false },
+  _selectSeparator: { type: Object, required: false },
+  una: { type: Object, required: false },
+  forceMount: { type: Boolean, required: false },
+  position: { type: String, required: false, default: "popper" },
+  bodyLock: { type: Boolean, required: false },
+  side: { type: null, required: false },
+  sideOffset: { type: Number, required: false },
+  align: { type: null, required: false },
+  alignOffset: { type: Number, required: false },
+  avoidCollisions: { type: Boolean, required: false },
+  collisionBoundary: { type: null, required: false },
+  collisionPadding: { type: [Number, Object], required: false },
+  arrowPadding: { type: Number, required: false },
+  sticky: { type: String, required: false },
+  hideWhenDetached: { type: Boolean, required: false },
+  positionStrategy: { type: String, required: false },
+  updatePositionStrategy: { type: String, required: false },
+  disableUpdateOnLayoutShift: { type: Boolean, required: false },
+  prioritizePosition: { type: Boolean, required: false },
+  reference: { type: null, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false }
+});
+const emits = defineEmits(["closeAutoFocus", "escapeKeyDown", "pointerDownOutside"]);
 const delegatedProps = computed(() => {
-  const { class: _, ...delegated } = props
-
-  return delegated
-})
-
-const forwarded = useForwardPropsEmits(delegatedProps, emits)
+  const { class: _, ...delegated } = props;
+  return delegated;
+});
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
 </script>
 
 <template>
   <SelectPortal>
     <SelectContent
       v-bind="{ ...forwarded, ...$attrs }"
-      :class="cn(
-        'select-content',
-        position === 'popper'
-          && 'select-content-popper',
-        props.class,
-      )
-      "
+      :class="
+  cn(
+    'select-content',
+    position === 'popper' && 'select-content-popper',
+    props.class
+  )
+"
     >
       <SelectScrollUpButton
         v-bind="_selectScrollUpButton"
       />
       <SelectViewport
-        :class="cn(
-          'select-viewport',
-          position === 'popper' && 'select-viewport-popper')
-        "
+        :class="
+  cn(
+    'select-viewport',
+    position === 'popper' && 'select-viewport-popper'
+  )
+"
       >
         <slot />
       </SelectViewport>

package/dist/runtime/components/forms/select/SelectContent.vue.d.ts

@@ -0,0 +1,27 @@
+import type { NSelectContentProps } from '../../../types/index.js';
+declare var __VLS_17: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NSelectContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: CustomEvent<{
+        originalEvent: PointerEvent;
+    }>) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<NSelectContentProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: CustomEvent<{
+        originalEvent: PointerEvent;
+    }>) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    position: "item-aligned" | "popper";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/forms/select/SelectGroup.vue

@@ -1,25 +1,27 @@
-<script setup lang="ts">
-import type { NSelectGroupProps } from '../../../types'
-import { SelectGroup } from 'reka-ui'
-import { computed } from 'vue'
-import { cn } from '../../../utils'
-
-const props = defineProps<NSelectGroupProps>()
-
+<script setup>
+import { SelectGroup } from "reka-ui";
+import { computed } from "vue";
+import { cn } from "../../../utils";
+const props = defineProps({
+  una: { type: Object, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false }
+});
 const delegatedProps = computed(() => {
-  const { class: _, ...delegated } = props
-
-  return delegated
-})
+  const { class: _, ...delegated } = props;
+  return delegated;
+});
 </script>
 
 <template>
   <SelectGroup
     :class="cn(
-      'select-group',
-      props.una?.selectGroup,
-      props.class,
-    )"
+  'select-group',
+  props.una?.selectGroup,
+  props.class
+)"
     v-bind="delegatedProps"
   >
     <slot />

package/dist/runtime/components/forms/select/SelectGroup.vue.d.ts

@@ -0,0 +1,13 @@
+import type { NSelectGroupProps } from '../../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NSelectGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NSelectGroupProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};