@nuxt/ui 4.0.0-alpha.1 → 4.0.0-alpha.2

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

@@ -0,0 +1,29 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ComponentConfig } from '../types/tv';
+import theme from '#build/ui/footer';
+type Footer = ComponentConfig<typeof theme, AppConfig, 'footer'>;
+export interface FooterProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'footer'
+     */
+    as?: any;
+    class?: any;
+    ui?: Footer['slots'];
+}
+export interface FooterSlots {
+    left(props?: {}): any;
+    default(props?: {}): any;
+    right(props?: {}): any;
+    top(props?: {}): any;
+    bottom(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FooterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FooterProps> & Readonly<{}>, {
+    as: any;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, FooterSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,57 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/footer-columns';
+import type { IconProps, LinkProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type FooterColumns = ComponentConfig<typeof theme, AppConfig, 'footerColumns'>;
+export interface FooterColumnLink extends Omit<LinkProps, 'custom'> {
+    label: string;
+    /**
+     * @IconifyIcon
+     */
+    icon?: IconProps['name'];
+    class?: any;
+    ui?: Pick<FooterColumns['slots'], 'item' | 'link' | 'linkLabel' | 'linkLabelExternalIcon' | 'linkLeadingIcon'>;
+}
+export interface FooterColumn<T extends FooterColumnLink = FooterColumnLink> {
+    label: string;
+    children?: T[];
+}
+export interface FooterColumnsProps<T extends FooterColumnLink = FooterColumnLink> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    class?: any;
+    columns?: FooterColumn<T>[];
+    ui?: FooterColumns['slots'];
+}
+type SlotProps<T> = (props: {
+    link: T;
+    active: boolean;
+}) => any;
+export interface FooterColumnsSlots<T extends FooterColumnLink = FooterColumnLink> {
+    'left'(props?: {}): any;
+    'default'(props?: {}): any;
+    'right'(props?: {}): any;
+    'column-label'?: (props: {
+        column: FooterColumn<T>;
+    }) => any;
+    'link': SlotProps<T>;
+    'link-leading': SlotProps<T>;
+    'link-label': SlotProps<T>;
+    'link-trailing': SlotProps<T>;
+}
+declare const _default: <T extends FooterColumnLink>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & FooterColumnsProps<T> & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: FooterColumnsSlots<T>;
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

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

@@ -0,0 +1,114 @@
+import type { FormSchema, FormError, FormInputEvents, FormErrorEvent, FormSubmitEvent, FormErrorWithId, InferInput, FormData } from '../types/form';
+export type FormProps<S extends FormSchema, T extends boolean = true, N extends boolean = false> = {
+    id?: string | number;
+    /** Schema to validate the form state. Supports Standard Schema objects, Yup, Joi, and Superstructs. */
+    schema?: S;
+    /** An object representing the current state of the form. */
+    state?: N extends false ? Partial<InferInput<S>> : never;
+    /**
+     * Custom validation function to validate the form state.
+     * @param state - The current state of the form.
+     * @returns A promise that resolves to an array of FormError objects, or an array of FormError objects directly.
+     */
+    validate?: (state: Partial<InferInput<S>>) => Promise<FormError[]> | FormError[];
+    /**
+     * The list of input events that trigger the form validation.
+     * @remarks The form always validates on submit.
+     * @defaultValue `['blur', 'change', 'input']`
+     */
+    validateOn?: FormInputEvents[];
+    /** Disable all inputs inside the form. */
+    disabled?: boolean;
+    /**
+     * Path of the form's state within it's parent form.
+     * Used for nesting forms. Only available if `nested` is true.
+     */
+    name?: N extends true ? string : never;
+    /**
+     * Delay in milliseconds before validating the form on input events.
+     * @defaultValue `300`
+     */
+    validateOnInputDelay?: number;
+    /**
+     * If true, applies schema transformations on submit.
+     * @defaultValue `true`
+     */
+    transform?: T;
+    /**
+     * If true, this form will attach to its parent Form and validate at the same time.
+     * @defaultValue `false`
+     */
+    nested?: N;
+    /**
+     * When `true`, all form elements will be disabled on `@submit` event.
+     * This will cause any focused input elements to lose their focus state.
+     * @defaultValue `true`
+     */
+    loadingAuto?: boolean;
+    class?: any;
+    onSubmit?: ((event: FormSubmitEvent<FormData<S, T>>) => void | Promise<void>) | (() => void | Promise<void>);
+};
+export interface FormEmits<S extends FormSchema, T extends boolean = true> {
+    submit: [event: FormSubmitEvent<FormData<S, T>>];
+    error: [event: FormErrorEvent];
+}
+export interface FormSlots {
+    default(props: {
+        errors: FormError[];
+        loading: boolean;
+    }): any;
+}
+declare const _default: <S extends FormSchema, T extends boolean = true, N extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onError?: ((event: FormErrorEvent) => any) | undefined;
+        readonly onSubmit?: ((event: FormSubmitEvent<FormData<S, T>>) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onSubmit" | "onError"> & FormProps<S, T, N> & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        validate: {
+            <T_1 extends boolean>(opts: {
+                name?: keyof InferInput<S> | (keyof InferInput<S>)[] | undefined;
+                silent?: false | undefined;
+                nested?: boolean;
+                transform?: T_1 | undefined;
+            }): Promise<FormData<S, T_1>>;
+            <T_1 extends boolean>(opts: {
+                name?: keyof InferInput<S> | (keyof InferInput<S>)[] | undefined;
+                silent?: true | undefined;
+                nested?: boolean;
+                transform?: T_1 | undefined;
+            }): Promise<FormData<S, T_1> | false>;
+        };
+        errors: import("vue").Ref<{
+            id?: string | undefined;
+            name?: string | undefined;
+            message: string;
+        }[], FormErrorWithId[] | {
+            id?: string | undefined;
+            name?: string | undefined;
+            message: string;
+        }[]>;
+        setErrors(errs: FormError[], name?: keyof InferInput<S> | string | RegExp): void;
+        submit(): Promise<void>;
+        getErrors(name?: keyof InferInput<S> | string | RegExp): {
+            id?: string | undefined;
+            name?: string | undefined;
+            message: string;
+        }[];
+        clear(name?: keyof InferInput<S> | string | RegExp): void;
+        disabled: import("vue").ComputedRef<boolean>;
+        loading: import("vue").Ref<boolean, boolean>;
+        dirty: import("vue").ComputedRef<boolean>;
+        dirtyFields: ReadonlySet<import("vue").DeepReadonly<import("@vue/reactivity").UnwrapRefSimple<keyof InferInput<S>>>>;
+        blurredFields: ReadonlySet<import("vue").DeepReadonly<import("@vue/reactivity").UnwrapRefSimple<keyof InferInput<S>>>>;
+        touchedFields: ReadonlySet<import("vue").DeepReadonly<import("@vue/reactivity").UnwrapRefSimple<keyof InferInput<S>>>>;
+    }>): void;
+    attrs: any;
+    slots: FormSlots;
+    emit: ((evt: "error", event: FormErrorEvent) => void) & ((evt: "submit", event: FormSubmitEvent<FormData<S, T>>) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/Form.vue

@@ -6,22 +6,23 @@ import theme from "#build/ui/form";
 import { provide, inject, nextTick, ref, onUnmounted, onMounted, computed, useId, readonly, reactive } from "vue";
 import { useEventBus } from "@vueuse/core";
 import { useAppConfig } from "#imports";
-import { formOptionsInjectionKey, formInputsInjectionKey, formBusInjectionKey, formLoadingInjectionKey, formErrorsInjectionKey } from "../composables/useFormField";
+import { formOptionsInjectionKey, formInputsInjectionKey, formBusInjectionKey, formLoadingInjectionKey, formErrorsInjectionKey, formStateInjectionKey } from "../composables/useFormField";
 import { tv } from "../utils/tv";
-import { validateSchema } from "../utils/form";
+import { validateSchema, getAtPath, setAtPath } from "../utils/form";
 import { FormValidationException } from "../types/form";
 const props = defineProps({
   id: { type: [String, Number], required: false },
   schema: { type: null, required: false },
-  state: { type: Object, required: true },
+  state: { type: null, required: false },
   validate: { type: Function, required: false },
   validateOn: { type: Array, required: false, default() {
     return ["input", "blur", "change"];
   } },
   disabled: { type: Boolean, required: false },
+  name: { type: null, required: false },
   validateOnInputDelay: { type: Number, required: false, default: 300 },
   transform: { type: null, required: false, default: () => true },
-  attach: { type: Boolean, required: false, default: true },
+  nested: { type: null, required: false },
   loadingAuto: { type: Boolean, required: false, default: true },
   class: { type: null, required: false },
   onSubmit: { type: Function, required: false }
@@ -32,16 +33,37 @@ const appConfig = useAppConfig();
 const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.form || {} }));
 const formId = props.id ?? useId();
 const bus = useEventBus(`form-${formId}`);
-const parentBus = props.attach && inject(
+const isNested = props.nested?.toString() === "" || props.nested === true;
+const parentBus = isNested && inject(
   formBusInjectionKey,
   void 0
 );
+const parentState = isNested ? inject(formStateInjectionKey, void 0) : void 0;
+const state = computed(() => {
+  if (parentState?.value) {
+    return props.name ? getAtPath(parentState.value, props.name) : parentState.value;
+  }
+  return props.state;
+});
 provide(formBusInjectionKey, bus);
+provide(formStateInjectionKey, state);
 const nestedForms = ref(/* @__PURE__ */ new Map());
+onMounted(async () => {
+  if (parentBus) {
+    await nextTick();
+    parentBus.emit({ type: "attach", validate: _validate, formId, name: props.name, api });
+  }
+});
+onUnmounted(() => {
+  bus.reset();
+  if (parentBus) {
+    parentBus.emit({ type: "detach", formId });
+  }
+});
 onMounted(async () => {
   bus.on(async (event) => {
     if (event.type === "attach") {
-      nestedForms.value.set(event.formId, { validate: event.validate });
+      nestedForms.value.set(event.formId, { validate: event.validate, name: event.name, api: event.api });
     } else if (event.type === "detach") {
       nestedForms.value.delete(event.formId);
     } else if (props.validateOn?.includes(event.type) && !loading.value) {
@@ -62,20 +84,6 @@ onMounted(async () => {
     }
   });
 });
-onUnmounted(() => {
-  bus.reset();
-});
-onMounted(async () => {
-  if (parentBus) {
-    await nextTick();
-    parentBus.emit({ type: "attach", validate: _validate, formId });
-  }
-});
-onUnmounted(() => {
-  if (parentBus) {
-    parentBus.emit({ type: "detach", formId });
-  }
-});
 const errors = ref([]);
 provide(formErrorsInjectionKey, errors);
 const inputs = ref({});
@@ -91,9 +99,9 @@ function resolveErrorIds(errs) {
 }
 const transformedState = ref(null);
 async function getErrors() {
-  let errs = props.validate ? await props.validate(props.state) ?? [] : [];
+  let errs = props.validate ? await props.validate(state.value) ?? [] : [];
   if (props.schema) {
-    const { errors: errors2, result } = await validateSchema(props.state, props.schema);
+    const { errors: errors2, result } = await validateSchema(state.value, props.schema);
     if (errors2) {
       errs = errs.concat(errors2);
     } else {
@@ -102,38 +110,52 @@ async function getErrors() {
   }
   return resolveErrorIds(errs);
 }
-async function _validate(opts = { silent: false, nested: true, transform: false }) {
+async function _validate(opts = { silent: false, nested: false, transform: false }) {
   const names = opts.name && !Array.isArray(opts.name) ? [opts.name] : opts.name;
-  const nestedValidatePromises = !names && opts.nested ? Array.from(nestedForms.value.values()).map(
-    ({ validate }) => validate(opts).then(() => void 0).catch((error) => {
+  async function validateNestedForms({ validate, name }) {
+    try {
+      return { name, output: await validate({ ...opts, silent: false }) };
+    } catch (error) {
       if (!(error instanceof FormValidationException)) {
         throw error;
       }
-      return error;
-    })
-  ) : [];
+      return { name, error };
+    }
+  }
+  const nestedValidatePromises = !names && opts.nested ? Array.from(nestedForms.value.values()).map(validateNestedForms) : [];
+  const nestedResults = await Promise.all(nestedValidatePromises);
+  const nestedErrors = nestedResults.flatMap((result) => {
+    if (!result.error) return [];
+    return result.error.errors.map((e) => ({ ...e, name: result.name ? [result.name, e.name].join(".") : e.name }));
+  });
+  const nestedOutputs = nestedResults.filter((c) => c.output !== void 0);
+  const allErrors = [await getErrors(), nestedErrors].flat();
   if (names) {
-    const otherErrors = errors.value.filter((error) => !names.some((name) => {
-      const pattern = inputs.value?.[name]?.pattern;
-      return name === error.name || pattern && error.name?.match(pattern);
-    }));
-    const pathErrors = (await getErrors()).filter((error) => names.some((name) => {
-      const pattern = inputs.value?.[name]?.pattern;
-      return name === error.name || pattern && error.name?.match(pattern);
-    }));
+    const namesSet = new Set(names);
+    const patterns = names.map((name) => inputs.value?.[name]?.pattern).filter(Boolean);
+    const isErrorForPath = (error) => {
+      if (!error.name) return false;
+      if (namesSet.has(error.name)) return true;
+      return patterns.some((pattern) => pattern.test(error.name));
+    };
+    const otherErrors = errors.value.filter((error) => !isErrorForPath(error));
+    const pathErrors = allErrors.filter(isErrorForPath);
     errors.value = otherErrors.concat(pathErrors);
   } else {
-    errors.value = await getErrors();
+    errors.value = allErrors;
   }
-  const childErrors = (await Promise.all(nestedValidatePromises)).filter((val) => val !== void 0);
-  if (errors.value.length + childErrors.length > 0) {
+  if (errors.value?.length) {
     if (opts.silent) return false;
-    throw new FormValidationException(formId, errors.value, childErrors);
+    throw new FormValidationException(formId, errors.value);
   }
   if (opts.transform) {
-    Object.assign(props.state, transformedState.value);
+    nestedOutputs.forEach((o) => {
+      if (o.name) setAtPath(transformedState.value, o.name, o.output);
+      else Object.assign(transformedState.value, o.output);
+    });
+    return transformedState.value ?? state.value;
   }
-  return props.state;
+  return state.value;
 }
 const loading = ref(false);
 provide(formLoadingInjectionKey, readonly(loading));
@@ -150,8 +172,7 @@ async function onSubmitWrapper(payload) {
     }
     const errorEvent = {
       ...event,
-      errors: error.errors,
-      children: error.children
+      errors: error.errors
     };
     emits("error", errorEvent);
   } finally {
@@ -163,15 +184,34 @@ provide(formOptionsInjectionKey, computed(() => ({
   disabled: disabled.value,
   validateOnInputDelay: props.validateOnInputDelay
 })));
-defineExpose({
+const api = {
   validate: _validate,
   errors,
   setErrors(errs, name) {
+    let formErrors = resolveErrorIds(errs).filter((e) => e.id);
     if (name) {
-      errors.value = errors.value.filter((err) => name instanceof RegExp ? !(err.name && name.test(err.name)) : err.name !== name).concat(resolveErrorIds(errs));
-    } else {
-      errors.value = resolveErrorIds(errs);
+      formErrors = errors.value.filter(
+        (err) => name instanceof RegExp ? !(err.name && name.test(err.name)) : err.name !== name
+      ).concat(formErrors);
+    }
+    for (const form of nestedForms.value.values()) {
+      const errors2 = errs.flatMap((e) => {
+        if (!form.name) return [e];
+        if (e?.name?.startsWith(form.name + `.`)) {
+          return [{
+            ...e,
+            name: e?.name.split(form.name + `.`)[1]
+          }];
+        }
+        return [];
+      });
+      const nameMatch = name instanceof RegExp ? form.name && name.test(form.name.toString()) : form.name !== name;
+      if (nameMatch || !form.name) {
+        form.api.setErrors(errors2, name);
+        formErrors = formErrors.concat(form.api.getErrors().map((e) => ({ ...e, name: form.name ? [form.name, e.name].join(".") : e.name })));
+      }
     }
+    errors.value = formErrors;
   },
   async submit() {
     await onSubmitWrapper(new Event("submit"));
@@ -183,11 +223,29 @@ defineExpose({
     return errors.value;
   },
   clear(name) {
+    let formErrors = [];
     if (name) {
-      errors.value = errors.value.filter((err) => name instanceof RegExp ? !(err.name && name.test(err.name)) : err.name !== name);
-    } else {
-      errors.value = [];
+      formErrors = errors.value.filter(
+        (err) => {
+          return err.name && !!inputs.value[err.name] && (name instanceof RegExp ? !(err.name && name.test(err.name)) : err.name !== name);
+        }
+      );
+    }
+    for (const form of nestedForms.value.values()) {
+      if (!form.name) form.api.clear(name);
+      else if (form.name === name || name instanceof RegExp && name.test(form.name)) form.api.clear();
+      else if (typeof name === "string" && name?.startsWith(form.name + `.`)) {
+        const nestedName = name?.split(`${form.name}.`)[1];
+        form.api.clear(nestedName);
+      }
+      formErrors = formErrors.concat(
+        form.api.getErrors().map((e) => ({
+          ...e,
+          name: form.name ? [form.name, e.name].join(".") : e.name
+        }))
+      );
     }
+    errors.value = formErrors;
   },
   disabled,
   loading,
@@ -195,7 +253,8 @@ defineExpose({
   dirtyFields: readonly(dirtyFields),
   blurredFields: readonly(blurredFields),
   touchedFields: readonly(touchedFields)
-});
+};
+defineExpose(api);
 </script>
 
 <template>

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

@@ -1,10 +1,10 @@
-import type { FormSchema, FormError, FormInputEvents, FormErrorEvent, FormSubmitEvent, Form, InferInput, FormData } from '../types/form';
-export interface FormProps<S extends FormSchema, T extends boolean = true> {
+import type { FormSchema, FormError, FormInputEvents, FormErrorEvent, FormSubmitEvent, FormErrorWithId, InferInput, FormData } from '../types/form';
+export type FormProps<S extends FormSchema, T extends boolean = true, N extends boolean = false> = {
     id?: string | number;
     /** Schema to validate the form state. Supports Standard Schema objects, Yup, Joi, and Superstructs. */
     schema?: S;
     /** An object representing the current state of the form. */
-    state: Partial<InferInput<S>>;
+    state?: N extends false ? Partial<InferInput<S>> : never;
     /**
      * Custom validation function to validate the form state.
      * @param state - The current state of the form.
@@ -19,21 +19,26 @@ export interface FormProps<S extends FormSchema, T extends boolean = true> {
     validateOn?: FormInputEvents[];
     /** Disable all inputs inside the form. */
     disabled?: boolean;
+    /**
+     * Path of the form's state within it's parent form.
+     * Used for nesting forms. Only available if `nested` is true.
+     */
+    name?: N extends true ? string : never;
     /**
      * Delay in milliseconds before validating the form on input events.
      * @defaultValue `300`
      */
     validateOnInputDelay?: number;
     /**
-     * If true, schema transformations will be applied to the state on submit.
+     * If true, applies schema transformations on submit.
      * @defaultValue `true`
      */
     transform?: T;
     /**
-     * If true, this form will attach to its parent Form (if any) and validate at the same time.
-     * @defaultValue `true`
+     * If true, this form will attach to its parent Form and validate at the same time.
+     * @defaultValue `false`
      */
-    attach?: boolean;
+    nested?: N;
     /**
      * When `true`, all form elements will be disabled on `@submit` event.
      * This will cause any focused input elements to lose their focus state.
@@ -42,7 +47,7 @@ export interface FormProps<S extends FormSchema, T extends boolean = true> {
     loadingAuto?: boolean;
     class?: any;
     onSubmit?: ((event: FormSubmitEvent<FormData<S, T>>) => void | Promise<void>) | (() => void | Promise<void>);
-}
+};
 export interface FormEmits<S extends FormSchema, T extends boolean = true> {
     submit: [event: FormSubmitEvent<FormData<S, T>>];
     error: [event: FormErrorEvent];
@@ -53,12 +58,50 @@ export interface FormSlots {
         loading: boolean;
     }): any;
 }
-declare const _default: <S extends FormSchema, T extends boolean = true>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+declare const _default: <S extends FormSchema, T extends boolean = true, N extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onError?: ((event: FormErrorEvent) => any) | undefined;
         readonly onSubmit?: ((event: FormSubmitEvent<FormData<S, T>>) => any) | undefined;
-    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onSubmit" | "onError"> & FormProps<S, T> & {}> & import("vue").PublicProps;
-    expose(exposed: import("vue").ShallowUnwrapRef<Form<S>>): void;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onSubmit" | "onError"> & FormProps<S, T, N> & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        validate: {
+            <T_1 extends boolean>(opts: {
+                name?: keyof InferInput<S> | (keyof InferInput<S>)[] | undefined;
+                silent?: false | undefined;
+                nested?: boolean;
+                transform?: T_1 | undefined;
+            }): Promise<FormData<S, T_1>>;
+            <T_1 extends boolean>(opts: {
+                name?: keyof InferInput<S> | (keyof InferInput<S>)[] | undefined;
+                silent?: true | undefined;
+                nested?: boolean;
+                transform?: T_1 | undefined;
+            }): Promise<FormData<S, T_1> | false>;
+        };
+        errors: import("vue").Ref<{
+            id?: string | undefined;
+            name?: string | undefined;
+            message: string;
+        }[], FormErrorWithId[] | {
+            id?: string | undefined;
+            name?: string | undefined;
+            message: string;
+        }[]>;
+        setErrors(errs: FormError[], name?: keyof InferInput<S> | string | RegExp): void;
+        submit(): Promise<void>;
+        getErrors(name?: keyof InferInput<S> | string | RegExp): {
+            id?: string | undefined;
+            name?: string | undefined;
+            message: string;
+        }[];
+        clear(name?: keyof InferInput<S> | string | RegExp): void;
+        disabled: import("vue").ComputedRef<boolean>;
+        loading: import("vue").Ref<boolean, boolean>;
+        dirty: import("vue").ComputedRef<boolean>;
+        dirtyFields: ReadonlySet<import("vue").DeepReadonly<import("@vue/reactivity").UnwrapRefSimple<keyof InferInput<S>>>>;
+        blurredFields: ReadonlySet<import("vue").DeepReadonly<import("@vue/reactivity").UnwrapRefSimple<keyof InferInput<S>>>>;
+        touchedFields: ReadonlySet<import("vue").DeepReadonly<import("@vue/reactivity").UnwrapRefSimple<keyof InferInput<S>>>>;
+    }>): void;
     attrs: any;
     slots: FormSlots;
     emit: ((evt: "error", event: FormErrorEvent) => void) & ((evt: "submit", event: FormSubmitEvent<FormData<S, T>>) => void);

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

@@ -0,0 +1,61 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/form-field';
+import type { ComponentConfig } from '../types/tv';
+type FormField = ComponentConfig<typeof theme, AppConfig, 'formField'>;
+export interface FormFieldProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /** The name of the FormField. Also used to match form errors. */
+    name?: string;
+    /** A regular expression to match form error names. */
+    errorPattern?: RegExp;
+    label?: string;
+    description?: string;
+    help?: string;
+    error?: boolean | string;
+    hint?: string;
+    /**
+     * @defaultValue 'md'
+     */
+    size?: FormField['variants']['size'];
+    required?: boolean;
+    /** If true, validation on input will be active immediately instead of waiting for a blur event. */
+    eagerValidation?: boolean;
+    /**
+     * Delay in milliseconds before validating the form on input events.
+     * @defaultValue `300`
+     */
+    validateOnInputDelay?: number;
+    class?: any;
+    ui?: FormField['slots'];
+}
+export interface FormFieldSlots {
+    label(props: {
+        label?: string;
+    }): any;
+    hint(props: {
+        hint?: string;
+    }): any;
+    description(props: {
+        description?: string;
+    }): any;
+    help(props: {
+        help?: string;
+    }): any;
+    error(props: {
+        error?: boolean | string;
+    }): any;
+    default(props: {
+        error?: boolean | string;
+    }): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FormFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, FormFieldSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};