@nuxt/ui 4.8.1 → 4.9.0

package/dist/runtime/locale/lv.js

@@ -0,0 +1,152 @@
+import { defineLocale } from "../composables/defineLocale.js";
+export default defineLocale({
+  name: "Latvie\u0161u",
+  code: "lv",
+  messages: {
+    alert: {
+      close: "Aizv\u0113rt"
+    },
+    authForm: {
+      hidePassword: "Pasl\u0113pt paroli",
+      showPassword: "R\u0101d\u012Bt paroli",
+      submit: "Turpin\u0101t"
+    },
+    banner: {
+      close: "Aizv\u0113rt"
+    },
+    calendar: {
+      nextMonth: "N\u0101kamais m\u0113nesis",
+      nextYear: "N\u0101kamais gads",
+      prevMonth: "Iepriek\u0161\u0113jais m\u0113nesis",
+      prevYear: "Iepriek\u0161\u0113jais gads"
+    },
+    carousel: {
+      dots: "Izv\u0113lies slaidu, ko r\u0101d\u012Bt",
+      goto: "P\u0101riet uz slaidu {slide}",
+      next: "N\u0101kamais",
+      prev: "Iepriek\u0161\u0113jais"
+    },
+    chatPrompt: {
+      placeholder: "Raksti savu zi\u0146u \u0161eit\u2026"
+    },
+    chatPromptSubmit: {
+      label: "S\u016Bt\u012Bt zi\u0146u"
+    },
+    colorMode: {
+      dark: "Tum\u0161s",
+      light: "Gai\u0161s",
+      switchToDark: "P\u0101rsl\u0113gt uz tum\u0161o re\u017E\u012Bmu",
+      switchToLight: "P\u0101rsl\u0113gt uz gai\u0161o re\u017E\u012Bmu",
+      system: "Sist\u0113mas"
+    },
+    commandPalette: {
+      back: "Atpaka\u013C",
+      close: "Aizv\u0113rt",
+      noData: "Nav datu",
+      noMatch: "Nav atbilsto\u0161u datu",
+      placeholder: "Ievadi komandu vai mekl\u0113\u2026"
+    },
+    contentSearch: {
+      links: "Saites",
+      search: "Rezult\u0101ti",
+      theme: "T\u0113ma"
+    },
+    contentSearchButton: {
+      label: "Mekl\u0113t\u2026"
+    },
+    contentToc: {
+      title: "\u0160aj\u0101 lap\u0101"
+    },
+    dropdownMenu: {
+      noMatch: "Nav atbilsto\u0161u datu",
+      search: "Mekl\u0113t\u2026"
+    },
+    dashboardSearch: {
+      theme: "T\u0113ma"
+    },
+    dashboardSearchButton: {
+      label: "Mekl\u0113t\u2026"
+    },
+    dashboardSidebarCollapse: {
+      collapse: "Sak\u013Caut s\u0101njoslu",
+      expand: "Izv\u0113rst s\u0101njoslu"
+    },
+    dashboardSidebarToggle: {
+      close: "Aizv\u0113rt s\u0101njoslu",
+      open: "Atv\u0113rt s\u0101njoslu"
+    },
+    error: {
+      clear: "Atpaka\u013C uz s\u0101kumlapu"
+    },
+    fileUpload: {
+      removeFile: "No\u0146emt {filename}"
+    },
+    header: {
+      close: "Aizv\u0113rt izv\u0113lni",
+      open: "Atv\u0113rt izv\u0113lni"
+    },
+    inputMenu: {
+      create: 'Izveidot "{label}"',
+      noData: "Nav datu",
+      noMatch: "Nav atbilsto\u0161u datu"
+    },
+    inputNumber: {
+      decrement: "Samazin\u0101t",
+      increment: "Palielin\u0101t"
+    },
+    listbox: {
+      noData: "Nav datu",
+      noMatch: "Nav atbilsto\u0161u datu",
+      search: "Mekl\u0113t\u2026"
+    },
+    modal: {
+      close: "Aizv\u0113rt"
+    },
+    pricingTable: {
+      caption: "Cenu sal\u012Bdzin\u0101jums"
+    },
+    prose: {
+      codeCollapse: {
+        closeText: "Sak\u013Caut",
+        name: "kods",
+        openText: "Izv\u0113rst"
+      },
+      collapsible: {
+        closeText: "Pasl\u0113pt",
+        name: "\u012Bpa\u0161\u012Bbas",
+        openText: "R\u0101d\u012Bt"
+      },
+      pre: {
+        copy: "Kop\u0113t kodu"
+      },
+      prompt: {
+        copy: "Kop\u0113t vaic\u0101jumu",
+        openIn: "Atv\u0113rt iek\u0161 {name}"
+      }
+    },
+    chatReasoning: {
+      thinking: "Dom\u0101\u2026",
+      thought: "Dom\u0101ja",
+      thoughtFor: "Dom\u0101ja {duration}"
+    },
+    sidebar: {
+      close: "Aizv\u0113rt",
+      toggle: "P\u0101rsl\u0113gt"
+    },
+    selectMenu: {
+      create: 'Izveidot "{label}"',
+      noData: "Nav datu",
+      noMatch: "Nav atbilsto\u0161u datu",
+      search: "Mekl\u0113t\u2026"
+    },
+    slideover: {
+      close: "Aizv\u0113rt"
+    },
+    table: {
+      noData: "Nav datu"
+    },
+    toast: {
+      close: "Aizv\u0113rt"
+    }
+  }
+});

package/dist/runtime/plugins/colors.js

@@ -1,6 +1,6 @@
 import { computed } from "vue";
 import colors from "tailwindcss/colors";
-import { defineNuxtPlugin, useAppConfig, useNuxtApp, useHead } from "#imports";
+import { defineNuxtPlugin, injectHead, useAppConfig, useNuxtApp, useHead } from "#imports";
 const shades = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
 function getColor(color, shade) {
   if (color in colors && typeof colors[color] === "object" && shade in colors[color]) {
@@ -15,6 +15,9 @@ function generateShades(key, value, prefix) {
 function generateColor(key, shade) {
   return `--ui-${key}: var(--ui-color-${key}-${shade});`;
 }
+function removeTemporaryColorsStyle() {
+  document.querySelector("[data-nuxt-ui-colors]")?.remove();
+}
 export default defineNuxtPlugin(() => {
   const appConfig = useAppConfig();
   const nuxtApp = useNuxtApp();
@@ -45,9 +48,7 @@ export default defineNuxtPlugin(() => {
     style.innerHTML = root.value;
     style.setAttribute("data-nuxt-ui-colors", "");
     document.head.appendChild(style);
-    headData.script = [{
-      innerHTML: "document.head.removeChild(document.querySelector('[data-nuxt-ui-colors]'))"
-    }];
+    injectHead().hooks.hookOnce("dom:rendered", removeTemporaryColorsStyle);
   }
   useHead(headData);
 });

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

@@ -1,11 +1,23 @@
 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;
+        [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;
     };
 } & {
@@ -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/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/stubs/base.d.ts

@@ -1,6 +1,6 @@
 import type { Ref } from 'vue';
 import type { NuxtApp } from '#app';
-export { useHead } from '@unhead/vue';
+export { injectHead, useHead } from '@unhead/vue';
 export { useAppConfig } from '../composables/useAppConfig';
 export { defineShortcuts } from '../../composables/defineShortcuts';
 export { defineLocale } from '../../composables/defineLocale';

package/dist/runtime/vue/stubs/base.js

@@ -2,7 +2,7 @@ import { ref, onScopeDispose } from "vue";
 import { createHooks } from "hookable";
 import { useColorMode as useColorModeVueUse } from "@vueuse/core";
 import appConfig from "#build/app.config";
-export { useHead } from "@unhead/vue";
+export { injectHead, useHead } from "@unhead/vue";
 export { useAppConfig } from "../composables/useAppConfig.js";
 export { defineShortcuts } from "../../composables/defineShortcuts.js";
 export { defineLocale } from "../../composables/defineLocale.js";