una-nuxt-module 2.1.2 → 2.1.3

package/dist/runtime/components/ui/auto-form/dependencies.js

@@ -0,0 +1,70 @@
+import { createContext } from "reka-ui";
+import { useFieldValue, useFormValues } from "vee-validate";
+import { computed, ref, watch } from "vue";
+import { DependencyType } from "./interface.js";
+import { getFromPath, getIndexIfArray } from "./utils.js";
+export const [injectDependencies, provideDependencies] = createContext("AutoFormDependencies");
+export default function useDependencies(fieldName) {
+  const form = useFormValues();
+  const currentFieldName = fieldName.replace(/\[\d+\]/g, "");
+  const currentFieldValue = useFieldValue(fieldName);
+  if (!form)
+    throw new Error("useDependencies should be used within <AutoForm>");
+  const dependencies = injectDependencies();
+  const isDisabled = ref(false);
+  const isHidden = ref(false);
+  const isRequired = ref(false);
+  const overrideOptions = ref();
+  const currentFieldDependencies = computed(() => dependencies.value?.filter(
+    (dependency) => dependency.targetField === currentFieldName
+  ));
+  function getSourceValue(dep) {
+    const source = dep.sourceField;
+    const index = getIndexIfArray(fieldName) ?? -1;
+    const [sourceLast, ...sourceInitial] = source.split(".").toReversed();
+    const [_targetLast, ...targetInitial] = dep.targetField.split(".").toReversed();
+    if (index >= 0 && sourceInitial.join(",") === targetInitial.join(",")) {
+      const [_currentLast, ...currentInitial] = fieldName.split(".").toReversed();
+      return getFromPath(form.value, currentInitial.join(".") + sourceLast);
+    }
+    return getFromPath(form.value, source);
+  }
+  const sourceFieldValues = computed(() => currentFieldDependencies.value?.map((dep) => getSourceValue(dep)));
+  const resetConditionState = () => {
+    isDisabled.value = false;
+    isHidden.value = false;
+    isRequired.value = false;
+    overrideOptions.value = void 0;
+  };
+  watch([sourceFieldValues, dependencies], () => {
+    resetConditionState();
+    currentFieldDependencies.value?.forEach((dep) => {
+      const sourceValue = getSourceValue(dep);
+      const conditionMet = dep.when(sourceValue, currentFieldValue.value);
+      switch (dep.type) {
+        case DependencyType.DISABLES:
+          if (conditionMet)
+            isDisabled.value = true;
+          break;
+        case DependencyType.REQUIRES:
+          if (conditionMet)
+            isRequired.value = true;
+          break;
+        case DependencyType.HIDES:
+          if (conditionMet)
+            isHidden.value = true;
+          break;
+        case DependencyType.SETS_OPTIONS:
+          if (conditionMet)
+            overrideOptions.value = dep.options;
+          break;
+      }
+    });
+  }, { immediate: true, deep: true });
+  return {
+    isDisabled,
+    isHidden,
+    isRequired,
+    overrideOptions
+  };
+}

package/dist/runtime/components/ui/auto-form/index.d.ts

@@ -0,0 +1,13 @@
+export { default as AutoForm } from './AutoForm.vue.js';
+export { default as AutoFormField } from './AutoFormField.vue.js';
+export { default as AutoFormFieldArray } from './AutoFormFieldArray.vue.js';
+export { default as AutoFormFieldBoolean } from './AutoFormFieldBoolean.vue.js';
+export { default as AutoFormFieldDate } from './AutoFormFieldDate.vue.js';
+export { default as AutoFormFieldEnum } from './AutoFormFieldEnum.vue.js';
+export { default as AutoFormFieldFile } from './AutoFormFieldFile.vue.js';
+export { default as AutoFormFieldInput } from './AutoFormFieldInput.vue.js';
+export { default as AutoFormFieldNumber } from './AutoFormFieldNumber.vue.js';
+export { default as AutoFormFieldObject } from './AutoFormFieldObject.vue.js';
+export { default as AutoFormLabel } from './AutoFormLabel.vue.js';
+export type { Config, ConfigItem, FieldProps } from './interface.js';
+export { getBaseSchema, getBaseType, getObjectFormSchema } from './utils.js';

package/dist/runtime/components/ui/auto-form/index.js

@@ -0,0 +1,12 @@
+export { default as AutoForm } from "./AutoForm.vue";
+export { default as AutoFormField } from "./AutoFormField.vue";
+export { default as AutoFormFieldArray } from "./AutoFormFieldArray.vue";
+export { default as AutoFormFieldBoolean } from "./AutoFormFieldBoolean.vue";
+export { default as AutoFormFieldDate } from "./AutoFormFieldDate.vue";
+export { default as AutoFormFieldEnum } from "./AutoFormFieldEnum.vue";
+export { default as AutoFormFieldFile } from "./AutoFormFieldFile.vue";
+export { default as AutoFormFieldInput } from "./AutoFormFieldInput.vue";
+export { default as AutoFormFieldNumber } from "./AutoFormFieldNumber.vue";
+export { default as AutoFormFieldObject } from "./AutoFormFieldObject.vue";
+export { default as AutoFormLabel } from "./AutoFormLabel.vue";
+export { getBaseSchema, getBaseType, getObjectFormSchema } from "./utils.js";

package/dist/runtime/components/ui/auto-form/interface.d.ts

@@ -0,0 +1,67 @@
+import type { Component, InputHTMLAttributes } from 'vue';
+import type { z, ZodAny } from 'zod';
+import type { INPUT_COMPONENTS } from './constant.js';
+export interface FieldProps {
+    fieldName: string;
+    label?: string;
+    required?: boolean;
+    config?: ConfigItem;
+    disabled?: boolean;
+}
+export interface Shape {
+    type: string;
+    default?: any;
+    required?: boolean;
+    options?: string[];
+    schema?: ZodAny;
+}
+export interface InputComponents {
+    date: Component;
+    select: Component;
+    radio: Component;
+    checkbox: Component;
+    switch: Component;
+    textarea: Component;
+    number: Component;
+    string: Component;
+    file: Component;
+    array: Component;
+    object: Component;
+}
+export interface ConfigItem {
+    /** Value for the `FormLabel` */
+    label?: string;
+    /** Value for the `FormDescription` */
+    description?: string;
+    /** Pick which component to be rendered. */
+    component?: keyof typeof INPUT_COMPONENTS | Component;
+    /** Hide `FormLabel`. */
+    hideLabel?: boolean;
+    inputProps?: InputHTMLAttributes;
+}
+type UnwrapArray<T> = T extends (infer U)[] ? U : never;
+export type Config<SchemaType extends object> = {
+    [Key in keyof SchemaType]?: SchemaType[Key] extends any[] ? UnwrapArray<Config<SchemaType[Key]>> : SchemaType[Key] extends object ? Config<SchemaType[Key]> : ConfigItem;
+};
+export declare enum DependencyType {
+    DISABLES = 0,
+    REQUIRES = 1,
+    HIDES = 2,
+    SETS_OPTIONS = 3
+}
+interface BaseDependency<SchemaType extends z.infer<z.ZodObject<any, any>>> {
+    sourceField: keyof SchemaType;
+    type: DependencyType;
+    targetField: keyof SchemaType;
+    when: (sourceFieldValue: any, targetFieldValue: any) => boolean;
+}
+export type ValueDependency<SchemaType extends z.infer<z.ZodObject<any, any>>> = BaseDependency<SchemaType> & {
+    type: DependencyType.DISABLES | DependencyType.REQUIRES | DependencyType.HIDES;
+};
+export type EnumValues = readonly [string, ...string[]];
+export type OptionsDependency<SchemaType extends z.infer<z.ZodObject<any, any>>> = BaseDependency<SchemaType> & {
+    type: DependencyType.SETS_OPTIONS;
+    options: EnumValues;
+};
+export type Dependency<SchemaType extends z.infer<z.ZodObject<any, any>>> = ValueDependency<SchemaType> | OptionsDependency<SchemaType>;
+export {};

package/dist/runtime/components/ui/auto-form/interface.js

@@ -0,0 +1,7 @@
+export var DependencyType = /* @__PURE__ */ ((DependencyType2) => {
+  DependencyType2[DependencyType2["DISABLES"] = 0] = "DISABLES";
+  DependencyType2[DependencyType2["REQUIRES"] = 1] = "REQUIRES";
+  DependencyType2[DependencyType2["HIDES"] = 2] = "HIDES";
+  DependencyType2[DependencyType2["SETS_OPTIONS"] = 3] = "SETS_OPTIONS";
+  return DependencyType2;
+})(DependencyType || {});

package/dist/runtime/components/ui/auto-form/utils.d.ts

@@ -0,0 +1,48 @@
+import type { z } from 'zod';
+export type ZodObjectOrWrapped = z.ZodObject<any, any> | z.ZodEffects<z.ZodObject<any, any>>;
+/**
+ * Beautify a camelCase string.
+ * e.g. "myString" -> "My String"
+ */
+export declare function beautifyObjectName(string: string): string;
+/**
+ * Parse string and extract the index
+ * @param string
+ * @returns index or undefined
+ */
+export declare function getIndexIfArray(string: string): number | undefined;
+/**
+ * Get the lowest level Zod type.
+ * This will unpack optionals, refinements, etc.
+ */
+export declare function getBaseSchema<ChildType extends z.ZodAny | z.AnyZodObject = z.ZodAny>(schema: ChildType | z.ZodEffects<ChildType>): ChildType | null;
+/**
+ * Get the type name of the lowest level Zod type.
+ * This will unpack optionals, refinements, etc.
+ */
+export declare function getBaseType(schema: z.ZodAny): "" | z.ZodFirstPartyTypeKind.ZodAny;
+/**
+ * Search for a "ZodDefault" in the Zod stack and return its value.
+ */
+export declare function getDefaultValueInZodStack(schema: z.ZodAny): any;
+export declare function getObjectFormSchema(schema: ZodObjectOrWrapped): z.ZodObject<any, any>;
+/**
+ * Constructs a path with dot paths for arrays to use brackets to be compatible with vee-validate path syntax
+ */
+export declare function normalizeFormPath(path: string): string;
+type NestedRecord = Record<string, unknown> | {
+    [k: string]: NestedRecord;
+};
+/**
+ * Checks if the path opted out of nested fields using `[fieldName]` syntax
+ */
+export declare function isNotNestedPath(path: string): boolean;
+/**
+ * Gets a nested property value from an object
+ */
+export declare function getFromPath<TValue = unknown>(object: NestedRecord | undefined, path: string): TValue | undefined;
+export declare function getFromPath<TValue = unknown, TFallback = TValue>(object: NestedRecord | undefined, path: string, fallback?: TFallback): TValue | TFallback;
+type Booleanish = boolean | 'true' | 'false';
+export declare function booleanishToBoolean(value: Booleanish): boolean;
+export declare function maybeBooleanishToBoolean(value?: Booleanish): boolean | undefined;
+export {};

package/dist/runtime/components/ui/auto-form/utils.js

@@ -0,0 +1,103 @@
+export function beautifyObjectName(string) {
+  let output = string.replace(/\[\d+\]/g, "").replace(/([A-Z])/g, " $1");
+  output = output.charAt(0).toUpperCase() + output.slice(1);
+  return output;
+}
+export function getIndexIfArray(string) {
+  const indexRegex = /\[(\d+)\]/;
+  const match = string.match(indexRegex);
+  const index = match ? Number.parseInt(match[1]) : void 0;
+  return index;
+}
+export function getBaseSchema(schema) {
+  if (!schema)
+    return null;
+  if ("innerType" in schema._def)
+    return getBaseSchema(schema._def.innerType);
+  if ("schema" in schema._def)
+    return getBaseSchema(schema._def.schema);
+  return schema;
+}
+export function getBaseType(schema) {
+  const baseSchema = getBaseSchema(schema);
+  return baseSchema ? baseSchema._def.typeName : "";
+}
+export function getDefaultValueInZodStack(schema) {
+  const typedSchema = schema;
+  if (typedSchema._def.typeName === "ZodDefault")
+    return typedSchema._def.defaultValue();
+  if ("innerType" in typedSchema._def) {
+    return getDefaultValueInZodStack(
+      typedSchema._def.innerType
+    );
+  }
+  if ("schema" in typedSchema._def) {
+    return getDefaultValueInZodStack(
+      typedSchema._def.schema
+    );
+  }
+  return void 0;
+}
+export function getObjectFormSchema(schema) {
+  if (schema?._def.typeName === "ZodEffects") {
+    const typedSchema = schema;
+    return getObjectFormSchema(typedSchema._def.schema);
+  }
+  return schema;
+}
+function isIndex(value) {
+  return Number(value) >= 0;
+}
+export function normalizeFormPath(path) {
+  const pathArr = path.split(".");
+  if (!pathArr.length)
+    return "";
+  let fullPath = String(pathArr[0]);
+  for (let i = 1; i < pathArr.length; i++) {
+    if (isIndex(pathArr[i])) {
+      fullPath += `[${pathArr[i]}]`;
+      continue;
+    }
+    fullPath += `.${pathArr[i]}`;
+  }
+  return fullPath;
+}
+export function isNotNestedPath(path) {
+  return /^\[.+\]$/.test(path);
+}
+function isObject(obj) {
+  return obj !== null && !!obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function isContainerValue(value) {
+  return isObject(value) || Array.isArray(value);
+}
+function cleanupNonNestedPath(path) {
+  if (isNotNestedPath(path))
+    return path.replace(/\[|\]/g, "");
+  return path;
+}
+export function getFromPath(object, path, fallback) {
+  if (!object)
+    return fallback;
+  if (isNotNestedPath(path))
+    return object[cleanupNonNestedPath(path)];
+  const resolvedValue = (path || "").split(/\.|\[(\d+)\]/).filter(Boolean).reduce((acc, propKey) => {
+    if (isContainerValue(acc) && propKey in acc)
+      return acc[propKey];
+    return fallback;
+  }, object);
+  return resolvedValue;
+}
+export function booleanishToBoolean(value) {
+  switch (value) {
+    case "true":
+    case true:
+      return true;
+    case "false":
+    case false:
+      return false;
+  }
+}
+export function maybeBooleanishToBoolean(value) {
+  return value ? booleanishToBoolean(value) : void 0;
+}

package/dist/runtime/components/ui/avatar/Avatar.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { AvatarRoot } from "reka-ui";
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <AvatarRoot
+    data-slot="avatar"
+    :class="
+  cn(
+    'relative flex size-8 shrink-0 overflow-hidden rounded-full',
+    props.class
+  )
+"
+  >
+    <slot />
+  </AvatarRoot>
+</template>

package/dist/runtime/components/ui/avatar/Avatar.vue.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes } from "vue";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/avatar/AvatarFallback.vue

@@ -0,0 +1,27 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { AvatarFallback } from "reka-ui";
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  delayMs: { type: Number, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false },
+  class: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <AvatarFallback
+    data-slot="avatar-fallback"
+    v-bind="delegatedProps"
+    :class="
+  cn(
+    'bg-muted flex size-full items-center justify-center rounded-full',
+    props.class
+  )
+"
+  >
+    <slot />
+  </AvatarFallback>
+</template>

package/dist/runtime/components/ui/avatar/AvatarFallback.vue.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes } from "vue";
+import { type AvatarFallbackProps } from "reka-ui";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AvatarFallbackProps & {
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AvatarFallbackProps & {
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/avatar/AvatarImage.vue

@@ -0,0 +1,20 @@
+<script setup>
+import { AvatarImage } from "reka-ui";
+const props = defineProps({
+  src: { type: String, required: true },
+  referrerPolicy: { type: null, required: false },
+  crossOrigin: { type: null, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false }
+});
+</script>
+
+<template>
+  <AvatarImage
+    data-slot="avatar-image"
+    v-bind="props"
+    class="aspect-square size-full"
+  >
+    <slot />
+  </AvatarImage>
+</template>

package/dist/runtime/components/ui/avatar/AvatarImage.vue.d.ts

@@ -0,0 +1,26 @@
+import type { AvatarImageProps } from 'reka-ui';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AvatarImageProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AvatarImageProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/avatar/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Avatar } from './Avatar.vue.js';
+export { default as AvatarFallback } from './AvatarFallback.vue.js';
+export { default as AvatarImage } from './AvatarImage.vue.js';

package/dist/runtime/components/ui/avatar/index.js

@@ -0,0 +1,3 @@
+export { default as Avatar } from "./Avatar.vue";
+export { default as AvatarFallback } from "./AvatarFallback.vue";
+export { default as AvatarImage } from "./AvatarImage.vue";

package/dist/runtime/components/ui/badge/Badge.vue

@@ -0,0 +1,23 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { Primitive } from "reka-ui";
+import { cn } from "../../../lib/utils";
+import { badgeVariants } from ".";
+const props = defineProps({
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false },
+  variant: { type: null, required: false },
+  class: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <Primitive
+    data-slot="badge"
+    :class="cn(badgeVariants({ variant }), props.class)"
+    v-bind="delegatedProps"
+  >
+    <slot />
+  </Primitive>
+</template>

package/dist/runtime/components/ui/badge/Badge.vue.d.ts

@@ -0,0 +1,34 @@
+import type { PrimitiveProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { type BadgeVariants } from ".";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<PrimitiveProps & {
+    variant?: BadgeVariants["variant"];
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<PrimitiveProps & {
+    variant?: BadgeVariants["variant"];
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/badge/index.d.ts

@@ -0,0 +1,6 @@
+import { type VariantProps } from 'class-variance-authority';
+export { default as Badge } from './Badge.vue.js';
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type BadgeVariants = VariantProps<typeof badgeVariants>;

package/dist/runtime/components/ui/badge/index.js

@@ -0,0 +1,18 @@
+import { cva } from "class-variance-authority";
+export { default as Badge } from "./Badge.vue";
+export const badgeVariants = cva(
+  "inline-flex items-center justify-center rounded-md border px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-[color,box-shadow] overflow-hidden",
+  {
+    variants: {
+      variant: {
+        default: "border-transparent bg-primary text-primary-foreground [a&]:hover:bg-primary/90",
+        secondary: "border-transparent bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90",
+        destructive: "border-transparent bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline: "text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);

package/dist/runtime/components/ui/breadcrumb/Breadcrumb.vue

@@ -0,0 +1,15 @@
+<script setup>
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <nav
+    aria-label="breadcrumb"
+    data-slot="breadcrumb"
+    :class="props.class"
+  >
+    <slot />
+  </nav>
+</template>

package/dist/runtime/components/ui/breadcrumb/Breadcrumb.vue.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes } from 'vue';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/breadcrumb/BreadcrumbEllipsis.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { MoreHorizontal } from "lucide-vue-next";
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <span
+    data-slot="breadcrumb-ellipsis"
+    role="presentation"
+    aria-hidden="true"
+    :class="cn('flex size-9 items-center justify-center', props.class)"
+  >
+    <slot>
+      <MoreHorizontal class="size-4" />
+    </slot>
+    <span class="sr-only">More</span>
+  </span>
+</template>