@nuxt/ui 3.0.0 → 3.0.2

package/dist/runtime/locale/uz.js

@@ -0,0 +1,54 @@
+import { defineLocale } from "../composables/defineLocale.js";
+export default defineLocale({
+  name: "O\u02BBzbek",
+  code: "uz",
+  messages: {
+    inputMenu: {
+      noMatch: "Mos keluvchi natija topilmadi",
+      noData: "Ma\u02BClumot yo\u02BBq",
+      create: '"{label}" yaratish'
+    },
+    calendar: {
+      prevYear: "Oldingi yil",
+      nextYear: "Keyingi yil",
+      prevMonth: "Oldingi oy",
+      nextMonth: "Keyingi oy"
+    },
+    inputNumber: {
+      increment: "Qo\u02BBshish",
+      decrement: "Ayirish"
+    },
+    commandPalette: {
+      placeholder: "Buyruq kiriting yoki qidiring...",
+      noMatch: "Mos keluvchi natija topilmadi",
+      noData: "Ma\u02BClumot yo\u02BBq",
+      close: "Yopish"
+    },
+    selectMenu: {
+      noMatch: "Mos keluvchi natija topilmadi",
+      noData: "Ma\u02BClumot yo\u02BBq",
+      create: '"{label}" yaratish',
+      search: "Qidirish..."
+    },
+    toast: {
+      close: "Yopish"
+    },
+    carousel: {
+      prev: "Ortga",
+      next: "Oldinga",
+      goto: "{slide}-slaydga o\u2018tish"
+    },
+    modal: {
+      close: "Yopish"
+    },
+    slideover: {
+      close: "Yopish"
+    },
+    alert: {
+      close: "Yopish"
+    },
+    table: {
+      noData: "Ma\u02BClumot yo\u02BBq"
+    }
+  }
+});

package/dist/runtime/plugins/colors.js

@@ -1,26 +1,33 @@
 import { computed } from "vue";
+import colors from "tailwindcss/colors";
 import { defineNuxtPlugin, 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]) {
+    return colors[color][shade];
+  }
+  return "";
+}
+function generateShades(key, value) {
+  return `${shades.map((shade) => `--ui-color-${key}-${shade}: var(--color-${value === "neutral" ? "old-neutral" : value}-${shade}, ${getColor(value, shade)});`).join("\n  ")}`;
+}
+function generateColor(key, shade) {
+  return `--ui-${key}: var(--ui-color-${key}-${shade});`;
+}
 export default defineNuxtPlugin(() => {
   const appConfig = useAppConfig();
   const nuxtApp = useNuxtApp();
-  const shades = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
-  function generateShades(key, value) {
-    return `${shades.map((shade) => `--ui-color-${key}-${shade}: var(--color-${value === "neutral" ? "old-neutral" : value}-${shade});`).join("\n  ")}`;
-  }
-  function generateColor(key, shade) {
-    return `--ui-${key}: var(--ui-color-${key}-${shade});`;
-  }
   const root = computed(() => {
-    const { neutral, ...colors } = appConfig.ui.colors;
+    const { neutral, ...colors2 } = appConfig.ui.colors;
     return `@layer base {
   :root {
   ${Object.entries(appConfig.ui.colors).map(([key, value]) => generateShades(key, value)).join("\n  ")}
   }
   :root, .light {
-  ${Object.keys(colors).map((key) => generateColor(key, 500)).join("\n  ")}
+  ${Object.keys(colors2).map((key) => generateColor(key, 500)).join("\n  ")}
   }
   .dark {
-  ${Object.keys(colors).map((key) => generateColor(key, 400)).join("\n  ")}
+  ${Object.keys(colors2).map((key) => generateColor(key, 400)).join("\n  ")}
   }
 }`;
   });
@@ -28,8 +35,7 @@ export default defineNuxtPlugin(() => {
     style: [{
       innerHTML: () => root.value,
       tagPriority: -2,
-      id: "nuxt-ui-colors",
-      type: "text/css"
+      id: "nuxt-ui-colors"
     }]
   };
   if (import.meta.client && nuxtApp.isHydrating && !nuxtApp.payload.serverRendered) {
@@ -41,7 +47,5 @@ export default defineNuxtPlugin(() => {
       innerHTML: "document.head.removeChild(document.querySelector('[data-nuxt-ui-colors]'))"
     }];
   }
-  if (!nuxtApp.isVue) {
-    useHead(headData);
-  }
+  useHead(headData);
 });

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

@@ -1,9 +1,7 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { ComputedRef, DeepReadonly, Ref } from 'vue';
-import type { ZodSchema } from 'zod';
 import type { Schema as JoiSchema } from 'joi';
 import type { ObjectSchema as YupObjectSchema } from 'yup';
-import type { GenericSchema as ValibotSchema, GenericSchemaAsync as ValibotSchemaAsync, SafeParser as ValibotSafeParser, SafeParserAsync as ValibotSafeParserAsync } from 'valibot';
 import type { GetObjectField } from './utils';
 import type { Struct as SuperstructSchema } from 'superstruct';
 export interface Form<T extends object> {
@@ -24,7 +22,7 @@ export interface Form<T extends object> {
     touchedFields: DeepReadonly<Set<keyof T>>;
     blurredFields: DeepReadonly<Set<keyof T>>;
 }
-export type FormSchema<T extends object> = ZodSchema | YupObjectSchema<T> | ValibotSchema | ValibotSchemaAsync | ValibotSafeParser<any, any> | ValibotSafeParserAsync<any, any> | JoiSchema<T> | SuperstructSchema<any, any> | StandardSchemaV1;
+export type FormSchema<T extends object> = YupObjectSchema<T> | JoiSchema<T> | SuperstructSchema<any, any> | StandardSchemaV1;
 export type FormInputEvents = 'input' | 'blur' | 'change' | 'focus';
 export interface FormError<P extends string = string> {
     name?: P;
@@ -70,6 +68,7 @@ export interface FormFieldInjectedOptions<T> {
     errorPattern?: RegExp;
     hint?: string;
     description?: string;
+    help?: string;
     ariaId: string;
 }
 export interface ValidateReturnSchema<T> {

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

@@ -6,6 +6,7 @@ export * from '../components/AvatarGroup.vue';
 export * from '../components/Badge.vue';
 export * from '../components/Breadcrumb.vue';
 export * from '../components/Button.vue';
+export * from '../components/ButtonGroup.vue';
 export * from '../components/Calendar.vue';
 export * from '../components/Card.vue';
 export * from '../components/Carousel.vue';
@@ -20,6 +21,7 @@ export * from '../components/Drawer.vue';
 export * from '../components/DropdownMenu.vue';
 export * from '../components/Form.vue';
 export * from '../components/FormField.vue';
+export * from '../components/Icon.vue';
 export * from '../components/Input.vue';
 export * from '../components/InputMenu.vue';
 export * from '../components/InputNumber.vue';

package/dist/runtime/types/index.js

@@ -6,6 +6,7 @@ export * from "../components/AvatarGroup.vue";
 export * from "../components/Badge.vue";
 export * from "../components/Breadcrumb.vue";
 export * from "../components/Button.vue";
+export * from "../components/ButtonGroup.vue";
 export * from "../components/Calendar.vue";
 export * from "../components/Card.vue";
 export * from "../components/Carousel.vue";
@@ -20,6 +21,7 @@ export * from "../components/Drawer.vue";
 export * from "../components/DropdownMenu.vue";
 export * from "../components/Form.vue";
 export * from "../components/FormField.vue";
+export * from "../components/Icon.vue";
 export * from "../components/Input.vue";
 export * from "../components/InputMenu.vue";
 export * from "../components/InputNumber.vue";

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

@@ -1,3 +1,4 @@
+import type { AcceptableValue as _AcceptableValue } from 'reka-ui';
 import type { VNode } from 'vue';
 export interface TightMap<O = any> {
     [key: string]: TightMap | O;
@@ -9,20 +10,39 @@ export type DeepPartial<T, O = any> = {
 };
 export type DynamicSlots<T extends {
     slot?: string;
-}, SlotProps, Slot = T['slot']> = Record<string, SlotProps> & (Slot extends string ? Record<Slot, SlotProps> : Record<string, never>);
+}, S extends string | undefined = undefined, D extends object = {}> = {
+    [K in T['slot'] as K extends string ? S extends string ? (K | `${K}-${S}`) : K : never]?: (props: {
+        item: Extract<T, {
+            slot: K extends `${infer Base}-${S}` ? Base : K;
+        }>;
+    } & D) => any;
+};
 export type GetObjectField<MaybeObject, Key extends string> = MaybeObject extends Record<string, any> ? MaybeObject[Key] : never;
 export type PartialString<T> = {
     [K in keyof T]?: string;
 };
-export type MaybeArrayOfArray<T> = T[] | T[][];
-export type MaybeArrayOfArrayItem<I> = I extends Array<infer T> ? T extends Array<infer U> ? U : T : never;
-export type SelectModelValue<T, V, M extends boolean = false, DV = T> = (T extends Record<string, any> ? V extends keyof T ? T[V] : DV : T) extends infer U ? M extends true ? U[] : U : never;
-export type SelectItemKey<T> = T extends Record<string, any> ? keyof T : string;
-export type SelectModelValueEmits<T, V, M extends boolean = false, DV = T> = {
-    'update:modelValue': [payload: SelectModelValue<T, V, M, DV>];
+export type AcceptableValue = Exclude<_AcceptableValue, Record<string, any>>;
+export type ArrayOrNested<T> = T[] | T[][];
+export type NestedItem<T> = T extends Array<infer I> ? NestedItem<I> : T;
+type AllKeys<T> = T extends any ? keyof T : never;
+type NonCommonKeys<T extends object> = Exclude<AllKeys<T>, keyof T>;
+type PickTypeOf<T, K extends string | number | symbol> = K extends AllKeys<T> ? T extends {
+    [k in K]?: any;
+} ? T[K] : undefined : never;
+export type MergeTypes<T extends object> = {
+    [k in keyof T]: PickTypeOf<T, k>;
+} & {
+    [k in NonCommonKeys<T>]?: PickTypeOf<T, k>;
+};
+export type GetItemKeys<I> = keyof Extract<NestedItem<I>, object>;
+export type GetItemValue<I, VK extends GetItemKeys<I> | undefined, T extends NestedItem<I> = NestedItem<I>> = T extends object ? VK extends undefined ? T : VK extends keyof T ? T[VK] : never : T;
+export type GetModelValue<T, VK extends GetItemKeys<T> | undefined, M extends boolean> = M extends true ? GetItemValue<T, VK>[] : GetItemValue<T, VK>;
+export type GetModelValueEmits<T, VK extends GetItemKeys<T> | undefined, M extends boolean> = {
+    /** Event handler called when the value changes. */
+    'update:modelValue': [payload: GetModelValue<T, VK, M>];
 };
-export type MaybeMultipleModelValue<T, M extends boolean = false> = (T extends infer U ? M extends true ? U[] : U : never);
 export type StringOrVNode = string | VNode | (() => VNode);
 export type EmitsToProps<T> = {
     [K in keyof T as `on${Capitalize<string & K>}`]: T[K] extends [...args: infer Args] ? (...args: Args) => void : never;
 };
+export {};

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

@@ -1,17 +1,13 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { ZodSchema } from 'zod';
 import type { ValidationError as JoiError, Schema as JoiSchema } from 'joi';
 import type { ObjectSchema as YupObjectSchema, ValidationError as YupError } from 'yup';
-import type { GenericSchema as ValibotSchema, GenericSchemaAsync as ValibotSchemaAsync, SafeParser as ValibotSafeParser, SafeParserAsync as ValibotSafeParserAsync } from 'valibot';
 import type { Struct } from 'superstruct';
 import type { FormSchema, ValidateReturnSchema } from '../types/form';
 export declare function isYupSchema(schema: any): schema is YupObjectSchema<any>;
 export declare function isYupError(error: any): error is YupError;
 export declare function isSuperStructSchema(schema: any): schema is Struct<any, any>;
-export declare function isZodSchema(schema: any): schema is ZodSchema;
 export declare function isJoiSchema(schema: any): schema is JoiSchema;
 export declare function isJoiError(error: any): error is JoiError;
-export declare function isValibotSchema(schema: any): schema is ValibotSchema | ValibotSchemaAsync | ValibotSafeParser<any, any> | ValibotSafeParserAsync<any, any>;
 export declare function isStandardSchema(schema: any): schema is StandardSchemaV1;
 export declare function validateStandardSchema(state: any, schema: StandardSchemaV1): Promise<ValidateReturnSchema<typeof state>>;
 export declare function validateSchema<T extends object>(state: T, schema: FormSchema<T>): Promise<ValidateReturnSchema<typeof state>>;

package/dist/runtime/utils/form.js

@@ -7,18 +7,12 @@ export function isYupError(error) {
 export function isSuperStructSchema(schema) {
   return "schema" in schema && typeof schema.coercer === "function" && typeof schema.validator === "function" && typeof schema.refiner === "function";
 }
-export function isZodSchema(schema) {
-  return schema.parse !== void 0;
-}
 export function isJoiSchema(schema) {
   return schema.validateAsync !== void 0 && schema.id !== void 0;
 }
 export function isJoiError(error) {
   return error.isJoi === true;
 }
-export function isValibotSchema(schema) {
-  return "_run" in schema || typeof schema === "function" && "schema" in schema;
-}
 export function isStandardSchema(schema) {
   return "~standard" in schema;
 }
@@ -77,23 +71,6 @@ async function validateSuperstructSchema(state, schema) {
     result
   };
 }
-async function validateZodSchema(state, schema) {
-  const result = await schema.safeParseAsync(state);
-  if (result.success === false) {
-    const errors = result.error.issues.map((issue) => ({
-      name: issue.path.join("."),
-      message: issue.message
-    }));
-    return {
-      errors,
-      result: null
-    };
-  }
-  return {
-    result: result.data,
-    errors: null
-  };
-}
 async function validateJoiSchema(state, schema) {
   try {
     const result = await schema.validateAsync(state, { abortEarly: false });
@@ -116,33 +93,11 @@ async function validateJoiSchema(state, schema) {
     }
   }
 }
-async function validateValibotSchema(state, schema) {
-  const result = await ("_run" in schema ? schema._run({ typed: false, value: state }, {}) : schema(state));
-  if (!result.issues || result.issues.length === 0) {
-    const output = "output" in result ? result.output : "value" in result ? result.value : null;
-    return {
-      errors: null,
-      result: output
-    };
-  }
-  const errors = result.issues.map((issue) => ({
-    name: issue.path?.map((item) => item.key).join(".") || "",
-    message: issue.message
-  }));
-  return {
-    errors,
-    result: null
-  };
-}
 export function validateSchema(state, schema) {
-  if (isZodSchema(schema)) {
-    return validateZodSchema(state, schema);
+  if (isStandardSchema(schema)) {
+    return validateStandardSchema(state, schema);
   } else if (isJoiSchema(schema)) {
     return validateJoiSchema(state, schema);
-  } else if (isStandardSchema(schema)) {
-    return validateStandardSchema(state, schema);
-  } else if (isValibotSchema(schema)) {
-    return validateValibotSchema(state, schema);
   } else if (isYupSchema(schema)) {
     return validateYupSchema(state, schema);
   } else if (isSuperStructSchema(schema)) {

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

@@ -4,3 +4,4 @@ export declare function get(object: Record<string, any> | undefined, path: (stri
 export declare function set(object: Record<string, any>, path: (string | number)[] | string, value: any): void;
 export declare function looseToNumber(val: any): any;
 export declare function compare<T>(value?: T, currentValue?: T, comparator?: string | ((a: T, b: T) => boolean)): boolean;
+export declare function isArrayOfArray<A>(item: A[] | A[][]): item is A[][];

package/dist/runtime/utils/index.js

@@ -61,3 +61,6 @@ export function compare(value, currentValue, comparator) {
   }
   return isEqual(value, currentValue);
 }
+export function isArrayOfArray(item) {
+  return Array.isArray(item[0]);
+}

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

@@ -1,29 +1,6 @@
 import type { LinkProps } from '../types';
 export declare function pickLinkProps(link: LinkProps & {
-    ariaLabel?: string;
-    title?: string;
+    [key: string]: any;
 }): {
-    replace: any;
-    type: any;
-    title: any;
-    exact: any;
-    active: any;
-    activeClass: any;
-    ariaCurrentValue: any;
-    ariaLabel: any;
-    as: any;
-    disabled: any;
-    exactActiveClass: any;
-    exactHash: any;
-    exactQuery: any;
-    external: any;
-    href: any;
-    inactiveClass: any;
-    noPrefetch: any;
-    noRel: any;
-    prefetch: any;
-    prefetchedClass: any;
-    rel: any;
-    target: any;
-    to: any;
+    [x: string]: any;
 };

package/dist/runtime/utils/link.js

@@ -1,4 +1,34 @@
 import { reactivePick } from "@vueuse/core";
 export function pickLinkProps(link) {
-  return reactivePick(link, "active", "activeClass", "ariaCurrentValue", "ariaLabel", "as", "disabled", "exact", "exactActiveClass", "exactHash", "exactQuery", "external", "href", "inactiveClass", "noPrefetch", "noRel", "prefetch", "prefetchedClass", "rel", "replace", "target", "to", "type", "title");
+  const keys = Object.keys(link);
+  const ariaKeys = keys.filter((key) => key.startsWith("aria-"));
+  const dataKeys = keys.filter((key) => key.startsWith("data-"));
+  const propsToInclude = [
+    "active",
+    "activeClass",
+    "ariaCurrentValue",
+    "as",
+    "disabled",
+    "exact",
+    "exactActiveClass",
+    "exactHash",
+    "exactQuery",
+    "external",
+    "href",
+    "inactiveClass",
+    "noPrefetch",
+    "noRel",
+    "prefetch",
+    "prefetchedClass",
+    "rel",
+    "replace",
+    "target",
+    "to",
+    "type",
+    "title",
+    "onClick",
+    ...ariaKeys,
+    ...dataKeys
+  ];
+  return reactivePick(link, ...propsToInclude);
 }

package/dist/runtime/utils/tv.js

@@ -1,4 +1,4 @@
 import { createTV } from "tailwind-variants";
 import _appConfig from "#build/app.config";
 const appConfigTv = _appConfig;
-export const tv = createTV(appConfigTv.ui?.tv);
+export const tv = /* @__PURE__ */ createTV(appConfigTv.ui?.tv);

package/dist/runtime/vue/components/Link.vue

@@ -103,6 +103,7 @@ defineOptions({ inheritAttrs: false })
 const props = withDefaults(defineProps<LinkProps>(), {
   as: 'button',
   type: 'button',
+  ariaCurrentValue: 'page',
   active: undefined,
   activeClass: '',
   inactiveClass: ''
@@ -204,6 +205,7 @@ function resolveLinkClass({ route, isActive, isExactActive }: any = {}) {
         <slot
           v-bind="{
             ...$attrs,
+            ...(exact && isExactActive ? { 'aria-current': props.ariaCurrentValue } : {}),
             as,
             type,
             disabled,
@@ -217,6 +219,7 @@ function resolveLinkClass({ route, isActive, isExactActive }: any = {}) {
         v-else
         v-bind="{
           ...$attrs,
+          ...(exact && isExactActive ? { 'aria-current': props.ariaCurrentValue } : {}),
           as,
           type,
           disabled,

package/dist/runtime/vue/plugins/head.js

@@ -1,6 +1,9 @@
 import { createHead } from "@unhead/vue/client";
 export default {
   install(app) {
+    if (app._context.provides.usehead) {
+      return;
+    }
     const head = createHead();
     app.use(head);
   }

package/dist/runtime/vue/stubs.d.ts

@@ -7,8 +7,8 @@ export { defineLocale } from '../composables/defineLocale';
 export { useLocale } from '../composables/useLocale';
 export declare const useColorMode: () => {
     forced: boolean;
-    preference?: undefined;
-    readonly value?: undefined;
+    preference?: "system" | "light" | "dark";
+    readonly value?: import("@vueuse/core").BasicColorMode;
 } | {
     preference: "system" | "light" | "dark";
     readonly value: import("@vueuse/core").BasicColorMode;
@@ -26,11 +26,15 @@ export declare const useCookie: <T = string>(_name: string, _options?: Record<st
 export declare const useState: <T>(key: string, init: () => T) => Ref<T>;
 export declare function useNuxtApp(): {
     isHydrating: boolean;
-    isVue: boolean;
     payload: {
         serverRendered: boolean;
     };
+    hooks: import("hookable").Hookable<Record<string, any>, string>;
+    hook: <NameT extends string>(name: NameT, function_: any, options?: {
+        allowDeprecated?: boolean;
+    }) => () => void;
 };
+export declare function useRuntimeHook(name: string, fn: (...args: any[]) => void): void;
 export declare function defineNuxtPlugin(plugin: (nuxtApp: NuxtApp) => void): {
     install(app: import("vue").App<any>): void;
 };

package/dist/runtime/vue/stubs.js

@@ -1,4 +1,5 @@
-import { ref } from "vue";
+import { ref, onScopeDispose } from "vue";
+import { createHooks } from "hookable";
 import appConfig from "#build/app.config";
 import { useColorMode as useColorModeVueUse } from "@vueuse/core";
 export { useHead } from "@unhead/vue";
@@ -50,17 +51,24 @@ export const useState = (key, init) => {
   state[key] = value;
   return value;
 };
+const hooks = createHooks();
 export function useNuxtApp() {
   return {
     isHydrating: true,
-    isVue: true,
-    payload: { serverRendered: false }
+    payload: { serverRendered: false },
+    hooks,
+    hook: hooks.hook
   };
 }
+export function useRuntimeHook(name, fn) {
+  const nuxtApp = useNuxtApp();
+  const unregister = nuxtApp.hook(name, fn);
+  onScopeDispose(unregister);
+}
 export function defineNuxtPlugin(plugin) {
   return {
     install(app) {
-      plugin({ vueApp: app });
+      app.runWithContext(() => plugin({ vueApp: app }));
     }
   };
 }