@nuxt/ui 4.8.2 → 4.10.0

package/dist/runtime/types/theme.d.ts

@@ -0,0 +1,187 @@
+import type { SlotClass } from './tv';
+import type * as ui from '#build/ui';
+import type * as ComponentTypes from './index';
+type ThemeSlotOverrides<T> = T extends {
+    slots: infer S extends Record<string, any>;
+} ? {
+    [K in keyof S]?: SlotClass;
+} : {
+    [K in keyof T]?: T[K] extends any[] ? SlotClass : T[K] extends Record<string, any> ? ThemeSlotOverrides<T[K]> : SlotClass;
+};
+/**
+ * Flat slot-class override shape: `{ button: { base: '...' }, modal: {...} }`.
+ * Powers the `:ui` prop on `<UTheme>`, which remains the recommended way to
+ * scope class overrides without touching component prop defaults.
+ */
+export type ThemeUI = {
+    [K in keyof typeof ui]?: ThemeSlotOverrides<(typeof ui)[K]>;
+};
+/**
+ * Strict per-component defaults shape used by `<UTheme :props>`. Authored as
+ * a flat interface with literal keys (rather than a mapped type) so editors —
+ * Volar in particular — surface key completions inside template inline
+ * objects (`:props="{ button: { … } }"`). Volar reliably iterates interface
+ * members but not mapped-type members in this position.
+ *
+ * Keys mirror the theme registry exposed by `#build/ui` (see
+ * `src/templates.ts`): every themable component gets one camelCase entry
+ * whose value is a `Partial` of that component's `<PascalCase>Props`.
+ */
+export interface ThemeDefaults {
+    accordion?: Partial<ComponentTypes.AccordionProps>;
+    alert?: Partial<ComponentTypes.AlertProps>;
+    authForm?: Partial<ComponentTypes.AuthFormProps>;
+    avatar?: Partial<ComponentTypes.AvatarProps>;
+    avatarGroup?: Partial<ComponentTypes.AvatarGroupProps>;
+    badge?: Partial<ComponentTypes.BadgeProps>;
+    banner?: Partial<ComponentTypes.BannerProps>;
+    blogPost?: Partial<ComponentTypes.BlogPostProps>;
+    blogPosts?: Partial<ComponentTypes.BlogPostsProps>;
+    breadcrumb?: Partial<ComponentTypes.BreadcrumbProps>;
+    button?: Partial<ComponentTypes.ButtonProps>;
+    calendar?: Partial<ComponentTypes.CalendarProps>;
+    card?: Partial<ComponentTypes.CardProps>;
+    carousel?: Partial<ComponentTypes.CarouselProps>;
+    changelogVersion?: Partial<ComponentTypes.ChangelogVersionProps>;
+    changelogVersions?: Partial<ComponentTypes.ChangelogVersionsProps>;
+    chatMessage?: Partial<ComponentTypes.ChatMessageProps>;
+    chatMessages?: Partial<ComponentTypes.ChatMessagesProps>;
+    chatPalette?: Partial<ComponentTypes.ChatPaletteProps>;
+    chatPrompt?: Partial<ComponentTypes.ChatPromptProps>;
+    chatPromptSubmit?: Partial<ComponentTypes.ChatPromptSubmitProps>;
+    chatReasoning?: Partial<ComponentTypes.ChatReasoningProps>;
+    chatShimmer?: Partial<ComponentTypes.ChatShimmerProps>;
+    chatTool?: Partial<ComponentTypes.ChatToolProps>;
+    checkbox?: Partial<ComponentTypes.CheckboxProps>;
+    checkboxGroup?: Partial<ComponentTypes.CheckboxGroupProps>;
+    chip?: Partial<ComponentTypes.ChipProps>;
+    collapsible?: Partial<ComponentTypes.CollapsibleProps>;
+    colorPicker?: Partial<ComponentTypes.ColorPickerProps>;
+    commandPalette?: Partial<ComponentTypes.CommandPaletteProps>;
+    container?: Partial<ComponentTypes.ContainerProps>;
+    contentNavigation?: Partial<ComponentTypes.ContentNavigationProps>;
+    contentSearch?: Partial<ComponentTypes.ContentSearchProps>;
+    contentSearchButton?: Partial<ComponentTypes.ContentSearchButtonProps>;
+    contentSurround?: Partial<ComponentTypes.ContentSurroundProps>;
+    contentToc?: Partial<ComponentTypes.ContentTocProps>;
+    contextMenu?: Partial<ComponentTypes.ContextMenuProps>;
+    dashboardGroup?: Partial<ComponentTypes.DashboardGroupProps>;
+    dashboardNavbar?: Partial<ComponentTypes.DashboardNavbarProps>;
+    dashboardPanel?: Partial<ComponentTypes.DashboardPanelProps>;
+    dashboardResizeHandle?: Partial<ComponentTypes.DashboardResizeHandleProps>;
+    dashboardSearch?: Partial<ComponentTypes.DashboardSearchProps>;
+    dashboardSearchButton?: Partial<ComponentTypes.DashboardSearchButtonProps>;
+    dashboardSidebar?: Partial<ComponentTypes.DashboardSidebarProps>;
+    dashboardSidebarCollapse?: Partial<ComponentTypes.DashboardSidebarCollapseProps>;
+    dashboardSidebarToggle?: Partial<ComponentTypes.DashboardSidebarToggleProps>;
+    dashboardToolbar?: Partial<ComponentTypes.DashboardToolbarProps>;
+    drawer?: Partial<ComponentTypes.DrawerProps>;
+    dropdownMenu?: Partial<ComponentTypes.DropdownMenuProps>;
+    editor?: Partial<ComponentTypes.EditorProps>;
+    editorDragHandle?: Partial<ComponentTypes.EditorDragHandleProps>;
+    editorToolbar?: Partial<ComponentTypes.EditorToolbarProps>;
+    empty?: Partial<ComponentTypes.EmptyProps>;
+    error?: Partial<ComponentTypes.ErrorProps>;
+    fieldGroup?: Partial<ComponentTypes.FieldGroupProps>;
+    fileUpload?: Partial<ComponentTypes.FileUploadProps>;
+    footer?: Partial<ComponentTypes.FooterProps>;
+    footerColumns?: Partial<ComponentTypes.FooterColumnsProps>;
+    form?: Partial<ComponentTypes.FormProps<any, any, any>>;
+    formField?: Partial<ComponentTypes.FormFieldProps>;
+    header?: Partial<ComponentTypes.HeaderProps>;
+    input?: Partial<ComponentTypes.InputProps>;
+    inputDate?: Partial<ComponentTypes.InputDateProps>;
+    inputMenu?: Partial<ComponentTypes.InputMenuProps>;
+    inputNumber?: Partial<ComponentTypes.InputNumberProps>;
+    inputRating?: Partial<ComponentTypes.InputRatingProps>;
+    inputTags?: Partial<ComponentTypes.InputTagsProps>;
+    inputTime?: Partial<ComponentTypes.InputTimeProps>;
+    kbd?: Partial<ComponentTypes.KbdProps>;
+    listbox?: Partial<ComponentTypes.ListboxProps>;
+    main?: Partial<ComponentTypes.MainProps>;
+    marquee?: Partial<ComponentTypes.MarqueeProps>;
+    modal?: Partial<ComponentTypes.ModalProps>;
+    navigationMenu?: Partial<ComponentTypes.NavigationMenuProps>;
+    page?: Partial<ComponentTypes.PageProps>;
+    pageAnchors?: Partial<ComponentTypes.PageAnchorsProps>;
+    pageAside?: Partial<ComponentTypes.PageAsideProps>;
+    pageBody?: Partial<ComponentTypes.PageBodyProps>;
+    pageCTA?: Partial<ComponentTypes.PageCTAProps>;
+    pageCard?: Partial<ComponentTypes.PageCardProps>;
+    pageColumns?: Partial<ComponentTypes.PageColumnsProps>;
+    pageFeature?: Partial<ComponentTypes.PageFeatureProps>;
+    pageGrid?: Partial<ComponentTypes.PageGridProps>;
+    pageHeader?: Partial<ComponentTypes.PageHeaderProps>;
+    pageHero?: Partial<ComponentTypes.PageHeroProps>;
+    pageLinks?: Partial<ComponentTypes.PageLinksProps>;
+    pageList?: Partial<ComponentTypes.PageListProps>;
+    pageLogos?: Partial<ComponentTypes.PageLogosProps>;
+    pageSection?: Partial<ComponentTypes.PageSectionProps>;
+    pagination?: Partial<ComponentTypes.PaginationProps>;
+    pinInput?: Partial<ComponentTypes.PinInputProps>;
+    popover?: Partial<ComponentTypes.PopoverProps>;
+    pricingPlan?: Partial<ComponentTypes.PricingPlanProps>;
+    pricingPlans?: Partial<ComponentTypes.PricingPlansProps>;
+    pricingTable?: Partial<ComponentTypes.PricingTableProps>;
+    progress?: Partial<ComponentTypes.ProgressProps>;
+    /**
+     * Prose components that expose overridable props, under a `prose` namespace
+     * (mirrors `app.config.ui.prose` and `useComponentProps('prose.<tag>', …)`).
+     * Set prop defaults per element to scope behavior for a subtree, e.g.
+     * `{ prose: { h2: { anchor: true }, img: { zoom: false } } }`. Class-only
+     * elements (`p`, `li`, `table`, `em`, …) are omitted — restyle them via `:ui`.
+     */
+    prose?: {
+        a?: Partial<ComponentTypes.ProseAProps>;
+        accordion?: Partial<ComponentTypes.ProseAccordionProps>;
+        callout?: Partial<ComponentTypes.ProseCalloutProps>;
+        card?: Partial<ComponentTypes.ProseCardProps>;
+        code?: Partial<ComponentTypes.ProseCodeProps>;
+        codeCollapse?: Partial<ComponentTypes.ProseCodeCollapseProps>;
+        codeGroup?: Partial<ComponentTypes.ProseCodeGroupProps>;
+        codeTree?: Partial<ComponentTypes.ProseCodeTreeProps>;
+        collapsible?: Partial<ComponentTypes.ProseCollapsibleProps>;
+        field?: Partial<ComponentTypes.ProseFieldProps>;
+        fieldGroup?: Partial<ComponentTypes.ProseFieldGroupProps>;
+        h1?: Partial<ComponentTypes.ProseH1Props>;
+        h2?: Partial<ComponentTypes.ProseH2Props>;
+        h3?: Partial<ComponentTypes.ProseH3Props>;
+        h4?: Partial<ComponentTypes.ProseH4Props>;
+        img?: Partial<ComponentTypes.ProseImgProps>;
+        pre?: Partial<ComponentTypes.ProsePreProps>;
+        prompt?: Partial<ComponentTypes.ProsePromptProps>;
+        steps?: Partial<ComponentTypes.ProseStepsProps>;
+        tabs?: Partial<ComponentTypes.ProseTabsProps>;
+        td?: Partial<ComponentTypes.ProseTdProps>;
+        th?: Partial<ComponentTypes.ProseThProps>;
+    };
+    radioGroup?: Partial<ComponentTypes.RadioGroupProps>;
+    scrollArea?: Partial<ComponentTypes.ScrollAreaProps>;
+    select?: Partial<ComponentTypes.SelectProps>;
+    selectMenu?: Partial<ComponentTypes.SelectMenuProps>;
+    separator?: Partial<ComponentTypes.SeparatorProps>;
+    sidebar?: Partial<ComponentTypes.SidebarProps>;
+    skeleton?: Partial<ComponentTypes.SkeletonProps>;
+    slideover?: Partial<ComponentTypes.SlideoverProps>;
+    slider?: Partial<ComponentTypes.SliderProps>;
+    stepper?: Partial<ComponentTypes.StepperProps>;
+    switch?: Partial<ComponentTypes.SwitchProps>;
+    table?: Partial<ComponentTypes.TableProps>;
+    tabs?: Partial<ComponentTypes.TabsProps>;
+    textarea?: Partial<ComponentTypes.TextareaProps>;
+    timeline?: Partial<ComponentTypes.TimelineProps>;
+    toast?: Partial<ComponentTypes.ToastProps>;
+    toaster?: Partial<ComponentTypes.ToasterProps>;
+    tooltip?: Partial<ComponentTypes.TooltipProps>;
+    tree?: Partial<ComponentTypes.TreeProps>;
+    user?: Partial<ComponentTypes.UserProps>;
+}
+/**
+ * Loose internal shape stored on the injected `ThemeContext`. Allows the
+ * `prose` namespace (lifted by `normalizeUi`) and any unknown keys to flow
+ * through without polluting the user-facing `ThemeDefaults` type.
+ */
+export type ThemeContextDefaults = ThemeDefaults & {
+    [name: string]: Record<string, any> | undefined;
+};
+export {};

package/dist/runtime/types/tv.d.ts

@@ -1,15 +1,27 @@
 import type { ClassValue, TVVariants, TVCompoundVariants, TVDefaultVariants } from 'tailwind-variants';
+/**
+ * A function form for a slot class that **replaces** the slot's default classes
+ * instead of merging onto them. It receives the slot's fully resolved default
+ * class string and returns the classes to use in its place.
+ * @example title: defaults => 'text-xl font-bold'
+ */
+export type SlotClassReplacer = (defaults: string) => ClassValue;
+/**
+ * The value accepted for a slot in `:ui`, the `class` prop or `app.config.ui`:
+ * either classes to merge (the default) or a {@link SlotClassReplacer} to replace.
+ */
+export type SlotClass = ClassValue | SlotClassReplacer;
 /**
  * Defines the AppConfig object based on the tailwind-variants configuration.
  */
 export type TVConfig<T extends Record<string, any>> = {
-    [P in keyof T]?: {
-        [K in keyof T[P] as K extends 'base' | 'slots' | 'variants' | 'defaultVariants' ? K : never]?: K extends 'base' ? ClassValue : K extends 'slots' ? {
-            [S in keyof T[P]['slots']]?: ClassValue;
+    [P in keyof T]?: P extends 'prose' ? TVConfig<T[P]> : {
+        [K in keyof T[P] as K extends 'base' | 'slots' | 'variants' | 'defaultVariants' ? K : never]?: K extends 'base' ? SlotClass : K extends 'slots' ? {
+            [S in keyof T[P]['slots']]?: SlotClass;
         } : K extends 'variants' ? TVVariants<T[P]['slots'], ClassValue, WidenVariantsValues<T[P]['variants']>> : K extends 'defaultVariants' ? TVDefaultVariants<WidenVariantsValues<T[P]['variants']>, T[P]['slots'], object, undefined> : never;
     };
 } & {
-    [P in keyof T]?: {
+    [P in keyof T]?: P extends 'prose' ? TVConfig<T[P]> : {
         compoundVariants?: TVCompoundVariants<WidenVariantsValues<T[P]['variants']>, T[P]['slots'], ClassValue, object, undefined>;
     };
 };
@@ -31,7 +43,7 @@ type ComponentVariants<T extends {
 type ComponentSlots<T extends {
     slots?: Record<string, any>;
 }> = Id<{
-    [K in keyof T['slots']]?: ClassValue;
+    [K in keyof T['slots']]?: SlotClass;
 }>;
 type ComponentUI<T extends {
     slots?: Record<string, any>;

package/dist/runtime/utils/ai.d.ts

@@ -14,13 +14,21 @@ export declare function isPartStreaming(part: {
     state?: string;
 }): boolean;
 /**
- * Checks if a tool part is still streaming (hasn't reached a terminal state).
+ * Checks if a tool part is still streaming (hasn't reached a terminal state
+ * and isn't paused waiting for a user approval).
  *
- * Terminal states are `output-available`, `output-error`, and `output-denied`.
+ * Terminal states are `output-available`, `output-error`, and `output-denied`,
+ * `approval-requested` is a paused state.
  */
 export declare function isToolStreaming(part: {
     state: string;
 }): boolean;
+/**
+ * Checks if a tool part is waiting for a user approval response.
+ */
+export declare function isToolApprovalPending(part: {
+    state: string;
+}): boolean;
 /**
  * Checks if a reasoning part is currently being streamed.
  *

package/dist/runtime/utils/ai.js

@@ -5,7 +5,10 @@ export function isPartStreaming(part) {
   return part.state === "streaming";
 }
 export function isToolStreaming(part) {
-  return !["output-available", "output-error", "output-denied"].includes(part.state);
+  return !["approval-requested", "output-available", "output-error", "output-denied"].includes(part.state);
+}
+export function isToolApprovalPending(part) {
+  return part.state === "approval-requested";
 }
 export function isReasoningStreaming(message, partIndex, chat) {
   if (chat.status !== "streaming") return false;

package/dist/runtime/utils/link.d.ts

@@ -1,4 +1,4 @@
-import type { LinkProps } from '../types';
+import type { LinkProps } from '../components/Link.vue';
 export declare const linkKeys: readonly ["active", "activeClass", "ariaCurrentValue", "as", "disabled", "download", "exact", "exactActiveClass", "exactHash", "exactQuery", "external", "form", "formaction", "formenctype", "formmethod", "formnovalidate", "formtarget", "href", "hreflang", "inactiveClass", "locale", "media", "noPrefetch", "noRel", "onClick", "ping", "prefetch", "prefetchOn", "prefetchedClass", "referrerpolicy", "rel", "replace", "target", "title", "to", "trailingSlash", "type", "viewTransition"];
 export declare function pickLinkProps(link: LinkProps & {
     [key: string]: any;

package/dist/runtime/utils/tv.d.ts

@@ -1 +1,41 @@
-export declare const tv: import("tailwind-variants").TV;
+import type { ClassValue, TVVariants, TVCompoundVariants, TVDefaultVariants, TVReturnType, defaultConfig } from 'tailwind-variants';
+type TVSlots = Record<string, ClassValue> | undefined;
+/**
+ * Widen the slot functions of a `tailwind-variants` return type so `class` /
+ * `className` also accept the `(defaults) => classes` replacer — `:ui` and the
+ * `class` prop flow straight into them. The concrete slot keys (and the
+ * extend-readable `slots` / `variants` / … properties) are preserved, so
+ * components keep type-checking under `noUncheckedIndexedAccess`.
+ */
+type WideSlotFn = (slotProps?: Record<string, any>) => string;
+type Widen<R> = R extends (props?: infer P) => infer Slots ? {
+    (props?: P): Slots extends string ? string : {
+        [K in keyof Slots]: WideSlotFn;
+    };
+} & Omit<R, never> : R;
+/**
+ * Mirrors `tailwind-variants`' `TV` call signature (so config inference is
+ * unchanged) but returns the {@link Widen}-ed result. Component prop types are
+ * derived from `typeof theme` via `ComponentConfig`, not from this type, so the
+ * widening only affects the internal `ui.slot(...)` calls.
+ */
+type WideTV = {
+    <V extends TVVariants<S, B, EV>, CV extends TVCompoundVariants<V, S, B, EV, ES>, DV extends TVDefaultVariants<V, S, EV, ES>, B extends ClassValue = undefined, S extends TVSlots = undefined, E extends TVReturnType = TVReturnType<V, S, B, EV extends undefined ? {} : EV, ES extends undefined ? {} : ES>, EV extends TVVariants<ES, B, E['variants'], ES> = E['variants'], ES extends TVSlots = E['slots'] extends TVSlots ? E['slots'] : undefined>(options: {
+        extend?: E;
+        base?: B;
+        slots?: S;
+        variants?: V;
+        compoundVariants?: CV;
+        compoundSlots?: any;
+        defaultVariants?: DV;
+    }, config?: typeof defaultConfig): Widen<TVReturnType<V, S, B, EV, ES, E>>;
+};
+/**
+ * Wraps `tailwind-variants`' `tv` so slot classes can be **replaced** (not just
+ * merged) through a function form — `(defaults) => classes` — in `:ui`, the
+ * `class` prop and `app.config.ui`. The wrapper is transparent for every other
+ * usage: it preserves the `TVReturnType` (so `extend: tv(theme)` keeps working
+ * via property reads) and only intercepts the slot functions on invocation.
+ */
+export declare const tv: WideTV;
+export {};

package/dist/runtime/utils/tv.js

@@ -1,4 +1,93 @@
-import { createTV } from "tailwind-variants";
+import { createTV, cnMerge } from "tailwind-variants";
 import appConfig from "#build/app.config";
 const appConfigTv = appConfig;
-export const tv = /* @__PURE__ */ createTV(appConfigTv.ui?.tv);
+const config = appConfigTv.ui?.tv;
+const baseTv = /* @__PURE__ */ createTV(config);
+function findReplacer(value) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (let i = value.length - 1; i >= 0; i--) {
+      const replacer = findReplacer(value[i]);
+      if (replacer) {
+        return replacer;
+      }
+    }
+  }
+  return void 0;
+}
+function plainClasses(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => plainClasses(item));
+  }
+  if (typeof value === "function") {
+    return [];
+  }
+  return [value];
+}
+function applyReplacer(replacer, slotProps, resolveDefaults) {
+  return cnMerge(replacer(resolveDefaults()), ...plainClasses(slotProps.class), ...plainClasses(slotProps.className))(config) ?? "";
+}
+function wrapSlots(slots, directives) {
+  return new Proxy(slots, {
+    get(target, key) {
+      const slot = target[key];
+      if (typeof slot !== "function") {
+        return slot;
+      }
+      return (slotProps = {}) => {
+        const replacer = findReplacer(slotProps.class) ?? findReplacer(slotProps.className) ?? directives?.[key];
+        if (!replacer) {
+          return slot(slotProps);
+        }
+        return applyReplacer(replacer, slotProps, () => slot({ ...slotProps, class: void 0, className: void 0 }));
+      };
+    }
+  });
+}
+function extractDirectives(componentConfig) {
+  if (!componentConfig || typeof componentConfig !== "object") {
+    return { config: componentConfig };
+  }
+  let config2 = componentConfig;
+  let directives;
+  if (typeof componentConfig.base === "function") {
+    directives = { base: componentConfig.base };
+    config2 = { ...config2, base: "" };
+  }
+  const slots = componentConfig.slots;
+  if (slots && typeof slots === "object") {
+    const replacers = Object.entries(slots).filter(([, value]) => typeof value === "function");
+    if (replacers.length) {
+      directives ??= {};
+      const cleaned = { ...slots };
+      for (const [slot, replacer] of replacers) {
+        directives[slot] = replacer;
+        cleaned[slot] = "";
+      }
+      config2 = { ...config2, slots: cleaned };
+    }
+  }
+  return { config: config2, directives };
+}
+export const tv = ((componentConfig) => {
+  const { config: cleanConfig, directives } = extractDirectives(componentConfig);
+  const component = baseTv(cleanConfig);
+  return new Proxy(component, {
+    apply(target, thisArg, args) {
+      const result = Reflect.apply(target, thisArg, args);
+      if (result && typeof result === "object") {
+        return wrapSlots(result, directives);
+      }
+      if (typeof result === "string") {
+        const slotProps = args[0] ?? {};
+        const replacer = findReplacer(slotProps.class) ?? findReplacer(slotProps.className) ?? directives?.base;
+        if (replacer) {
+          return applyReplacer(replacer, slotProps, () => Reflect.apply(target, thisArg, [{ ...slotProps, class: void 0, className: void 0 }]));
+        }
+      }
+      return result;
+    }
+  });
+});

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

@@ -1,4 +1,4 @@
-import type { IconProps } from '../../types';
+import type { IconProps } from '../../components/Icon.vue';
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -1,4 +1,4 @@
-import type { IconProps } from '../../types';
+import type { IconProps } from '../../components/Icon.vue';
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/vue/components/color-mode/ColorModeSelect.d.vue.ts

@@ -1,4 +1,4 @@
-import type { SelectMenuProps, SelectMenuItem } from '../../../types';
+import type { SelectMenuProps, SelectMenuItem } from '../../../components/SelectMenu.vue';
 export interface ColorModeSelectProps extends Omit<SelectMenuProps<SelectMenuItem[]>, 'icon' | 'items' | 'modelValue'> {
 }
 declare const _default: typeof __VLS_export;

package/dist/runtime/vue/components/color-mode/ColorModeSelect.vue.d.ts

@@ -1,4 +1,4 @@
-import type { SelectMenuProps, SelectMenuItem } from '../../../types';
+import type { SelectMenuProps, SelectMenuItem } from '../../../components/SelectMenu.vue';
 export interface ColorModeSelectProps extends Omit<SelectMenuProps<SelectMenuItem[]>, 'icon' | 'items' | 'modelValue'> {
 }
 declare const _default: typeof __VLS_export;

package/dist/runtime/vue/components/color-mode/ColorModeSwitch.d.vue.ts

@@ -1,4 +1,4 @@
-import type { SwitchProps } from '../../../types';
+import type { SwitchProps } from '../../../components/Switch.vue';
 export interface ColorModeSwitchProps extends Omit<SwitchProps, 'checkedIcon' | 'uncheckedIcon' | 'modelValue'> {
 }
 declare const _default: typeof __VLS_export;

package/dist/runtime/vue/components/color-mode/ColorModeSwitch.vue.d.ts

@@ -1,4 +1,4 @@
-import type { SwitchProps } from '../../../types';
+import type { SwitchProps } from '../../../components/Switch.vue';
 export interface ColorModeSwitchProps extends Omit<SwitchProps, 'checkedIcon' | 'uncheckedIcon' | 'modelValue'> {
 }
 declare const _default: typeof __VLS_export;

package/dist/runtime/vue/overrides/inertia/Link.d.vue.ts

@@ -63,10 +63,10 @@ export interface LinkSlots {
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
-    type: "reset" | "submit" | "button";
     as: any;
-    active: boolean;
+    type: "reset" | "submit" | "button";
     ariaCurrentValue: "page" | "step" | "location" | "date" | "time" | "true" | "false";
+    active: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/runtime/vue/overrides/inertia/Link.vue

@@ -68,9 +68,9 @@ const props = defineProps({
 defineSlots();
 const page = usePage();
 const appConfig = useAppConfig();
-const routerLinkProps = useForwardProps(reactiveOmit(props, "as", "type", "disabled", "active", "exact", "activeClass", "inactiveClass", "to", "href", "raw", "custom", "class", "noRel"));
+const routerLinkProps = useForwardProps(reactiveOmit(props, "as", "type", "disabled", "active", "exact", "activeClass", "inactiveClass", "to", "href", "raw", "custom", "class", "target", "rel", "noRel"));
 const ui = computed(() => tv({
-  extend: tv(theme),
+  extend: theme,
   ...defu({
     variants: {
       active: {

package/dist/runtime/vue/overrides/inertia/Link.vue.d.ts

@@ -63,10 +63,10 @@ export interface LinkSlots {
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
-    type: "reset" | "submit" | "button";
     as: any;
-    active: boolean;
+    type: "reset" | "submit" | "button";
     ariaCurrentValue: "page" | "step" | "location" | "date" | "time" | "true" | "false";
+    active: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/runtime/vue/overrides/inertia/LinkBase.d.vue.ts

@@ -1,9 +1,9 @@
-import type { LinkProps } from '../../../types';
+import type { LinkProps } from '../../../components/Link.vue';
 export interface LinkBaseProps {
     as?: string;
     type?: string;
     disabled?: boolean;
-    onClick?: ((e: MouseEvent) => void | Promise<void>) | Array<((e: MouseEvent) => void | Promise<void>)>;
+    onClick?: ((e: MouseEvent) => void) | Array<((e: MouseEvent) => void)>;
     href?: string;
     target?: LinkProps['target'];
     rel?: LinkProps['rel'];
@@ -13,8 +13,8 @@ export interface LinkBaseProps {
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkBaseProps> & Readonly<{}>, {
-    type: string;
     as: string;
+    type: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 } & {

package/dist/runtime/vue/overrides/inertia/LinkBase.vue.d.ts

@@ -1,9 +1,9 @@
-import type { LinkProps } from '../../../types';
+import type { LinkProps } from '../../../components/Link.vue';
 export interface LinkBaseProps {
     as?: string;
     type?: string;
     disabled?: boolean;
-    onClick?: ((e: MouseEvent) => void | Promise<void>) | Array<((e: MouseEvent) => void | Promise<void>)>;
+    onClick?: ((e: MouseEvent) => void) | Array<((e: MouseEvent) => void)>;
     href?: string;
     target?: LinkProps['target'];
     rel?: LinkProps['rel'];
@@ -13,8 +13,8 @@ export interface LinkBaseProps {
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkBaseProps> & Readonly<{}>, {
-    type: string;
     as: string;
+    type: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 } & {

package/dist/runtime/vue/overrides/none/Link.d.vue.ts

@@ -64,10 +64,10 @@ export interface LinkSlots {
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
-    type: "reset" | "submit" | "button";
     as: any;
-    active: boolean;
+    type: "reset" | "submit" | "button";
     ariaCurrentValue: string;
+    active: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/runtime/vue/overrides/none/Link.vue

@@ -36,7 +36,7 @@ const props = defineProps({
 defineSlots();
 const appConfig = useAppConfig();
 const ui = computed(() => tv({
-  extend: tv(theme),
+  extend: theme,
   ...defu({
     variants: {
       active: {
@@ -59,6 +59,7 @@ const isExternal = computed(() => {
   }
   return hasProtocol(href.value, { acceptRelative: true });
 });
+const hasTarget = computed(() => !!props.target && props.target !== "_self");
 const isLinkActive = computed(() => {
   if (props.active !== void 0) {
     return props.active;
@@ -72,14 +73,14 @@ const linkClass = computed(() => {
   }
   return ui.value({ class: props.class, active, disabled: props.disabled });
 });
-const linkRel = computed(() => {
+const rel = computed(() => {
   if (props.noRel) {
     return null;
   }
-  if (props.rel) {
-    return props.rel;
+  if (props.rel !== void 0) {
+    return props.rel || null;
   }
-  if (isExternal.value) {
+  if (isExternal.value || hasTarget.value) {
     return "noopener noreferrer";
   }
   return null;
@@ -104,7 +105,7 @@ const navigate = handleNavigation ? (e) => {
   disabled,
   href,
   navigate,
-  rel: linkRel,
+  rel,
   target: target || (isExternal ? '_blank' : void 0),
   isExternal,
   active: isLinkActive
@@ -120,7 +121,7 @@ const navigate = handleNavigation ? (e) => {
   disabled,
   href,
   navigate,
-  rel: linkRel,
+  rel,
   target: target || (isExternal ? '_blank' : void 0),
   isExternal
 }"

package/dist/runtime/vue/overrides/none/Link.vue.d.ts

@@ -64,10 +64,10 @@ export interface LinkSlots {
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
-    type: "reset" | "submit" | "button";
     as: any;
-    active: boolean;
+    type: "reset" | "submit" | "button";
     ariaCurrentValue: string;
+    active: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/runtime/vue/overrides/vue-router/Link.d.vue.ts

@@ -56,10 +56,10 @@ export interface LinkSlots {
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
-    type: "reset" | "submit" | "button";
     as: any;
-    active: boolean;
+    type: "reset" | "submit" | "button";
     ariaCurrentValue: "page" | "step" | "location" | "date" | "time" | "true" | "false";
+    active: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {