@aifuxi/semi-ui-vue 0.1.0-alpha.0

package/dist/form/FormErrorMessage.vue.d.ts

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

package/dist/form/FormField.d.ts

@@ -0,0 +1,9 @@
+import { Component, VNode } from 'vue';
+import { CommonFieldProps, FormFieldComponent, WithFieldOptions } from './types';
+interface InternalWithFieldOptions extends WithFieldOptions {
+    shouldInjectByDefault?: boolean;
+}
+export declare function createFormField<Props extends object>(control: Component, options?: InternalWithFieldOptions): FormFieldComponent<Props & CommonFieldProps>;
+export declare function isFormFieldVNode(value: unknown): value is VNode;
+export declare const withField: typeof createFormField;
+export {};

package/dist/form/FormInputGroup.d.ts

@@ -0,0 +1,62 @@
+import { FormInputGroupProps } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    extraText: {
+        type: null;
+        default: undefined;
+    };
+    extraTextPosition: {
+        type: () => "bottom" | "middle";
+        default: string;
+    };
+    label: {
+        type: null;
+        default: undefined;
+    };
+    labelPosition: {
+        type: () => "left" | "top";
+        default: undefined;
+    };
+    size: {
+        type: () => FormInputGroupProps["size"];
+        default: string;
+    };
+}>, (() => null) | (() => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>), {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    extraText: {
+        type: null;
+        default: undefined;
+    };
+    extraTextPosition: {
+        type: () => "bottom" | "middle";
+        default: string;
+    };
+    label: {
+        type: null;
+        default: undefined;
+    };
+    labelPosition: {
+        type: () => "left" | "top";
+        default: undefined;
+    };
+    size: {
+        type: () => FormInputGroupProps["size"];
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    size: import('..').InputSize | undefined;
+    label: any;
+    labelPosition: "left" | "top";
+    extraText: any;
+    extraTextPosition: "middle" | "bottom";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/form/FormLabel.vue.d.ts

@@ -0,0 +1,18 @@
+import { FormLabelProps } from './types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<FormLabelProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FormLabelProps> & Readonly<{}>, {
+    optional: boolean;
+    required: boolean;
+    align: import('./types').FormLabelAlign;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/form/FormNodeRenderer.d.ts

@@ -0,0 +1,15 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/form/FormSection.vue.d.ts

@@ -0,0 +1,16 @@
+import { FormSectionProps } from './types';
+declare var __VLS_1: {}, __VLS_8: {};
+type __VLS_Slots = {} & {
+    text?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<FormSectionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FormSectionProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/form/FormSlot.d.ts

@@ -0,0 +1,3 @@
+import { FormSlotComponentProps } from './types';
+declare const _default: import('vue').DefineComponent<FormSlotComponentProps>;
+export default _default;

package/dist/form/form-context.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey } from 'vue';
+import { ArrayFieldContextValue, FormContextValue } from './internal-types';
+export declare const formContextKey: InjectionKey<FormContextValue>;
+export declare const arrayFieldContextKey: InjectionKey<ArrayFieldContextValue>;

package/dist/form/index.d.ts

@@ -0,0 +1,68 @@
+import { Component, DefineComponent } from 'vue';
+import { default as FormErrorMessage } from './FormErrorMessage.vue';
+import { createFormField, withField } from './FormField';
+import { default as FormLabel } from './FormLabel.vue';
+import { default as FormSection } from './FormSection.vue';
+import { default as FormSlot } from './FormSlot';
+import { ArrayFieldProps, FormAutoCompleteProps, FormCheckboxProps, FormFieldComponent, FormInputGroupProps, FormProps, FormRadioProps, FormSelectProps } from './types';
+import { useFieldApi, useFieldState, useForm, useFormApi, useFormState } from './use-form';
+import { withFormApi, withFormState } from './with-form';
+export declare const FormInput: FormFieldComponent<Omit<import('..').InputProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormInputNumber: FormFieldComponent<Omit<import('..').InputNumberProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormTextArea: FormFieldComponent<Omit<import('..').TextAreaProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export interface FormSelectComponent extends FormFieldComponent<FormSelectProps> {
+    Option: Component;
+    OptGroup: Component;
+}
+export declare const FormSelect: FormSelectComponent;
+export declare const FormCheckboxGroup: FormFieldComponent<Omit<import('..').CheckboxGroupProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormCheckbox: FormFieldComponent<FormCheckboxProps>;
+export declare const FormRadioGroup: FormFieldComponent<Omit<import('..').RadioGroupProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormRadio: FormFieldComponent<FormRadioProps>;
+export declare const FormDatePicker: FormFieldComponent<Omit<import('..').DatePickerProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormSwitch: FormFieldComponent<Omit<import('..').SwitchProps, "modelValue" | "checked" | "defaultChecked"> & import('./types').CommonFieldProps>;
+export declare const FormSlider: FormFieldComponent<Omit<import('..').SliderProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormTimePicker: FormFieldComponent<Omit<import('..').TimePickerProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormTreeSelect: FormFieldComponent<Omit<import('..').TreeSelectProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormCascader: FormFieldComponent<Omit<import('..').CascaderProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormRating: FormFieldComponent<Omit<import('..').RatingProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export interface FormAutoCompleteComponent extends FormFieldComponent<FormAutoCompleteProps> {
+    Option: Component;
+}
+export declare const FormAutoComplete: FormAutoCompleteComponent;
+export declare const FormUpload: FormFieldComponent<Omit<import('..').UploadProps, "modelValue" | "defaultFileList" | "fileList"> & import('./types').CommonFieldProps>;
+export declare const FormTagInput: FormFieldComponent<Omit<import('..').TagInputProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const FormPinCode: FormFieldComponent<Omit<import('..').PinCodeProps, "value" | "defaultValue" | "modelValue"> & import('./types').CommonFieldProps>;
+export declare const ArrayField: DefineComponent<ArrayFieldProps>;
+export interface FormCompoundComponent extends DefineComponent<FormProps> {
+    AutoComplete: typeof FormAutoComplete;
+    Cascader: typeof FormCascader;
+    Checkbox: typeof FormCheckbox;
+    CheckboxGroup: typeof FormCheckboxGroup;
+    DatePicker: typeof FormDatePicker;
+    ErrorMessage: typeof FormErrorMessage;
+    Input: typeof FormInput;
+    InputGroup: DefineComponent<FormInputGroupProps>;
+    InputNumber: typeof FormInputNumber;
+    Label: typeof FormLabel;
+    PinCode: typeof FormPinCode;
+    Radio: typeof FormRadio;
+    RadioGroup: typeof FormRadioGroup;
+    Rating: typeof FormRating;
+    Section: typeof FormSection;
+    Select: typeof FormSelect;
+    Slider: typeof FormSlider;
+    Slot: typeof FormSlot;
+    Switch: typeof FormSwitch;
+    TagInput: typeof FormTagInput;
+    TextArea: typeof FormTextArea;
+    TimePicker: typeof FormTimePicker;
+    TreeSelect: typeof FormTreeSelect;
+    Upload: typeof FormUpload;
+    useForm: typeof useForm;
+}
+export declare const Form: FormCompoundComponent;
+export declare const Field: typeof createFormField;
+export { createFormField, useFieldApi, useFieldState, useForm, useFormApi, useFormState, withField, withFormApi, withFormState, };
+export type { ArrayFieldItem, ArrayFieldProps, ArrayFieldSlotProps, ArrayFieldSlots, CommonFieldProps, FieldApi, FieldValidator, FormApi, FormAutoCompleteProps, FormCascaderProps, FormCheckboxGroupProps, FormCheckboxProps, FormComponentPublicInstance, FormDatePickerProps, FormEmits, FormErrorMessageProps, FormFieldComponent, FormFieldError, FormInputGroupProps, FormInputNumberProps, FormInputProps, FormLabelAlign, FormLabelPosition, FormLabelProps, FormLayout, FormPinCodeProps, FormProps, FormRadioGroupProps, FormRadioProps, FormRatingProps, FormRule, FormRuleType, FormScrollToErrorOptions, FormSectionProps, FormSelectProps, FormSliderProps, FormSlotComponentProps, FormSlotProps, FormSlots, FormState, FormSwitchProps, FormTagInputProps, FormTextAreaProps, FormTimePickerProps, FormTreeSelectProps, FormTrigger, FormUploadProps, FormValidateOptions, FormValidateStatus, FormValidator, ScrollIntoViewOptions, WithField, WithFieldOptions, } from './types';
+export default Form;

package/dist/form/index.js

@@ -0,0 +1,3 @@
+import { A as e, C as t, D as n, E as r, O as i, S as a, T as o, _ as s, a as c, b as l, c as u, d, f, g as p, h as m, i as h, j as g, k as _, l as v, m as y, n as b, o as x, p as S, r as C, s as w, t as T, u as E, v as D, w as O, x as k, y as A } from "../form-CLhGuORQ.js";
+import "../slider/index.js";
+export { T as ArrayField, b as Field, C as Form, C as default, h as FormAutoComplete, c as FormCascader, x as FormCheckbox, w as FormCheckboxGroup, u as FormDatePicker, v as FormInput, E as FormInputNumber, d as FormPinCode, f as FormRadio, S as FormRadioGroup, y as FormRating, m as FormSelect, p as FormSlider, s as FormSwitch, D as FormTagInput, A as FormTextArea, l as FormTimePicker, k as FormTreeSelect, a as FormUpload, e as createFormField, o as useFieldApi, r as useFieldState, n as useForm, i as useFormApi, _ as useFormState, g as withField, t as withFormApi, O as withFormState };

package/dist/form/internal-types.d.ts

@@ -0,0 +1,67 @@
+import { Ref } from 'vue';
+import { FormApi, FormProps, FormState } from './types';
+interface InternalCallOptions {
+    allowEmpty?: boolean;
+    fieldAllowEmpty?: boolean;
+    needClone?: boolean;
+    notNotify?: boolean;
+    notUpdate?: boolean;
+    silent?: boolean;
+}
+interface InternalFieldApi {
+    reset(): void;
+    setError(error: unknown, options?: InternalCallOptions): void;
+    setTouched(touched: boolean | undefined, options?: InternalCallOptions): void;
+    setValue(value: unknown, options?: InternalCallOptions): void;
+    validate(value: unknown, options?: InternalCallOptions): Promise<unknown>;
+}
+export interface InternalFormUpdater {
+    getArrayField(field: string): {
+        initValue?: unknown;
+        updateKey?: string | number;
+    } | undefined;
+    getError(field?: string): unknown;
+    getField(field: string): unknown;
+    getFormProps(fields?: string[]): Record<string, unknown>;
+    getInitValue(field: string): unknown;
+    getInitValues(): Record<string, unknown>;
+    getTouched(field?: string): unknown;
+    getValue(field?: string, options?: InternalCallOptions): unknown;
+    register(field: string, state: {
+        error?: unknown | undefined;
+        status?: string | undefined;
+        touched?: boolean | undefined;
+        value?: unknown | undefined;
+    }, staff: {
+        allowEmpty?: boolean;
+        field: string;
+        fieldApi: InternalFieldApi;
+        keepState?: boolean;
+    }): void;
+    registerArrayField(field: string, value: unknown): void;
+    unRegister(field: string): void;
+    unRegisterArrayField(field: string): void;
+    updateArrayField(field: string, value: {
+        initValue?: unknown;
+        updateKey?: string | number;
+    }): void;
+    updateStateError(field: string, error: unknown, options?: InternalCallOptions, callback?: () => void): void;
+    updateStateTouched(field: string, touched: boolean | undefined, options?: InternalCallOptions, callback?: () => void): void;
+    updateStateValue(field: string, value: unknown, options?: InternalCallOptions, callback?: () => void): void;
+}
+export interface ExternalFormController<Values extends Record<string, unknown> = Record<string, unknown>> extends FormApi<Values> {
+    __bind?: (api: FormApi<Values>) => void;
+    __unbind?: () => void;
+    __updateState?: (state: FormState<Values>) => void;
+}
+export interface FormContextValue {
+    api: FormApi;
+    props: Readonly<FormProps>;
+    state: Ref<FormState>;
+    updater: InternalFormUpdater;
+}
+export interface ArrayFieldContextValue {
+    inArrayField: boolean;
+    shouldUseInitValue: boolean;
+}
+export {};

package/dist/form/types.d.ts

@@ -0,0 +1,273 @@
+import { Component, ComponentPublicInstance, ComputedRef, CSSProperties, DefineComponent, HTMLAttributes, Ref, VNodeChild } from 'vue';
+import { AutoCompleteProps } from '../auto-complete';
+import { CascaderProps } from '../cascader';
+import { CheckboxGroupProps, CheckboxProps } from '../checkbox';
+import { DatePickerProps } from '../date-picker';
+import { ColProps } from '../grid';
+import { InputGroupProps, InputProps, TextAreaProps } from '../input';
+import { InputNumberProps } from '../input-number';
+import { PinCodeProps } from '../pin-code';
+import { RadioGroupProps, RadioProps } from '../radio';
+import { RatingProps } from '../rating';
+import { SelectProps } from '../select';
+import { SliderProps } from '../slider';
+import { SwitchProps } from '../switch';
+import { TagInputProps } from '../tag-input';
+import { TimePickerProps } from '../time-picker';
+import { TreeSelectProps } from '../tree-select';
+import { UploadProps } from '../upload';
+export type FormLayout = 'vertical' | 'horizontal';
+export type FormLabelPosition = 'top' | 'left' | 'inset';
+export type FormLabelAlign = 'left' | 'right';
+export type FormValidateStatus = 'default' | 'error' | 'warning' | 'success';
+export type FormTrigger = 'blur' | 'change' | 'custom' | 'mount';
+export type FormFieldError = boolean | string | unknown[] | VNodeChild | undefined;
+export type FormRuleType = 'any' | 'array' | 'boolean' | 'date' | 'email' | 'enum' | 'float' | 'hex' | 'integer' | 'method' | 'number' | 'object' | 'regexp' | 'string' | 'url';
+export interface FormRule {
+    asyncValidator?: (...args: unknown[]) => void | Promise<void>;
+    defaultField?: FormRule;
+    enum?: Array<boolean | null | number | string | undefined>;
+    fields?: Record<string, FormRule | FormRule[]>;
+    len?: number;
+    max?: number;
+    message?: string | (() => string);
+    min?: number;
+    options?: Record<string, unknown>;
+    pattern?: RegExp | string;
+    required?: boolean;
+    transform?: (value: unknown) => unknown;
+    type?: FormRuleType;
+    validator?: (...args: unknown[]) => boolean | Error | Error[];
+    whitespace?: boolean;
+}
+export interface FormState<Values extends Record<string, unknown> = Record<string, unknown>> {
+    values: Values;
+    errors: Record<string, FormFieldError>;
+    touched: Record<string, unknown>;
+}
+export interface FormValidateOptions<Field extends string = string> {
+    fields?: Field[];
+    silent?: boolean;
+}
+export interface FormScrollToErrorOptions {
+    field?: string;
+    index?: number;
+    scrollOpts?: ScrollIntoViewOptions;
+}
+export interface ScrollIntoViewOptions {
+    behavior?: 'auto' | 'smooth' | ((actions: unknown[]) => unknown[]);
+    block?: 'start' | 'center' | 'end' | 'nearest';
+    inline?: 'start' | 'center' | 'end' | 'nearest';
+    scrollMode?: 'always' | 'if-needed';
+    boundary?: Element | ((parent: Element) => boolean) | null;
+}
+export interface FormApi<Values extends Record<string, unknown> = Record<string, unknown>> {
+    getValue(field?: string): unknown;
+    setValue(field: string, value: unknown): void;
+    getValues(): Values;
+    setValues(values: Partial<Values>, options?: {
+        isOverride?: boolean;
+    }): void;
+    getError(field?: string): FormFieldError | Record<string, FormFieldError>;
+    setError(field: string, error: FormFieldError): void;
+    getTouched(field?: string): unknown;
+    setTouched(field: string, touched: boolean): void;
+    getFormState(): FormState<Values>;
+    getFormProps(fields?: string[]): Partial<FormProps<Values>>;
+    getInitValue(field: string): unknown;
+    getInitValues(): Values;
+    getFieldExist(field: string): boolean;
+    reset(fields?: string[]): void;
+    validate(fields?: string[] | FormValidateOptions): Promise<Values>;
+    submitForm(): void;
+    scrollToField(field: string, options?: ScrollIntoViewOptions): void;
+    scrollToError(options?: FormScrollToErrorOptions): void;
+}
+export interface FieldApi {
+    getError(): FormFieldError;
+    setError(error: FormFieldError): void;
+    getTouched(): unknown;
+    setTouched(touched: boolean): void;
+    getValue(): unknown;
+    setValue(value: unknown): void;
+}
+export interface FormSlotProps<Values extends Record<string, unknown> = Record<string, unknown>> {
+    formState: FormState<Values>;
+    formApi: FormApi<Values>;
+    values: Values;
+}
+export interface FormProps<Values extends Record<string, unknown> = Record<string, unknown>> {
+    allowEmpty?: boolean;
+    ariaLabel?: string;
+    autoScrollToError?: boolean | ScrollIntoViewOptions;
+    className?: HTMLAttributes['class'];
+    component?: Component;
+    disabled?: boolean;
+    extraTextPosition?: 'middle' | 'bottom';
+    form?: FormApi<Values>;
+    getFormApi?: (formApi: FormApi<Values>) => void;
+    id?: string;
+    initValues?: Partial<Values>;
+    labelAlign?: FormLabelAlign;
+    labelCol?: ColProps;
+    labelPosition?: FormLabelPosition;
+    labelWidth?: number | string;
+    layout?: FormLayout;
+    render?: (props: FormSlotProps<Values>) => VNodeChild;
+    showValidateIcon?: boolean;
+    stopPropagation?: {
+        submit?: boolean;
+        reset?: boolean;
+    };
+    stopValidateWithError?: boolean;
+    style?: CSSProperties;
+    trigger?: FormTrigger | FormTrigger[];
+    validateFields?: FormValidator<Values>;
+    validator?: FormValidator<Values>;
+    wrapperCol?: ColProps;
+}
+export type FormValidator<Values extends Record<string, unknown>> = (values: Values) => string | Partial<Record<keyof Values, FormFieldError>> | Promise<string | Partial<Record<keyof Values, FormFieldError>>>;
+export interface FormEmits<Values extends Record<string, unknown> = Record<string, unknown>> {
+    change: [formState: FormState<Values>];
+    errorChange: [
+        errors: Record<string, FormFieldError>,
+        changedErrors: Record<string, FormFieldError>
+    ];
+    reset: [];
+    submit: [values: Values, event?: Event];
+    submitFail: [errors: unknown, values: Values, event?: Event];
+    valueChange: [values: Values, changedValues: Partial<Values>];
+}
+export interface FormSlots<Values extends Record<string, unknown> = Record<string, unknown>> {
+    default?: (props: FormSlotProps<Values>) => VNodeChild;
+}
+export interface FormLabelProps {
+    align?: FormLabelAlign;
+    className?: HTMLAttributes['class'];
+    disabled?: boolean;
+    extra?: VNodeChild;
+    id?: string;
+    name?: string;
+    optional?: boolean;
+    required?: boolean;
+    style?: CSSProperties;
+    text?: VNodeChild;
+    width?: number | string;
+}
+export interface FormErrorMessageProps {
+    className?: HTMLAttributes['class'];
+    error?: FormFieldError;
+    errorMessageId?: string;
+    helpText?: VNodeChild;
+    helpTextId?: string;
+    isInInputGroup?: boolean;
+    showValidateIcon?: boolean;
+    style?: CSSProperties;
+    validateStatus?: FormValidateStatus;
+}
+export interface CommonFieldProps {
+    allowEmptyString?: boolean;
+    convert?: (value: unknown) => unknown;
+    emptyValue?: unknown;
+    extraText?: VNodeChild;
+    extraTextPosition?: 'middle' | 'bottom';
+    field: string;
+    fieldClassName?: HTMLAttributes['class'];
+    fieldStyle?: CSSProperties;
+    helpText?: VNodeChild;
+    initValue?: unknown;
+    keepState?: boolean;
+    label?: FormLabelProps | VNodeChild;
+    labelAlign?: FormLabelAlign;
+    labelCol?: ColProps;
+    labelPosition?: FormLabelPosition;
+    labelWidth?: number | string;
+    name?: string;
+    noErrorMessage?: boolean;
+    noLabel?: boolean;
+    pure?: boolean;
+    required?: boolean;
+    rules?: FormRule[];
+    stopValidateWithError?: boolean;
+    transform?: (value: unknown) => unknown;
+    trigger?: FormTrigger | FormTrigger[];
+    validate?: FieldValidator;
+    validator?: FieldValidator;
+    validateStatus?: FormValidateStatus;
+    wrapperCol?: ColProps;
+}
+export type FieldValidator = (fieldValue: unknown, values: Record<string, unknown>) => string | undefined | Promise<string | undefined>;
+type StandardFieldProps<Props> = Omit<Props, 'defaultValue' | 'modelValue' | 'value'> & CommonFieldProps;
+type CheckedFieldProps<Props> = Omit<Props, 'checked' | 'defaultChecked' | 'modelValue'> & CommonFieldProps;
+type UploadFieldProps<Props> = Omit<Props, 'defaultFileList' | 'fileList' | 'modelValue'> & CommonFieldProps;
+type OptionalField<Props> = Omit<Props, 'field'> & {
+    field?: string;
+};
+export type FormInputProps = StandardFieldProps<InputProps>;
+export type FormTextAreaProps = StandardFieldProps<TextAreaProps>;
+export type FormInputNumberProps = StandardFieldProps<InputNumberProps>;
+export type FormSelectProps = StandardFieldProps<SelectProps>;
+export type FormCheckboxProps = OptionalField<CheckedFieldProps<CheckboxProps>>;
+export type FormCheckboxGroupProps = StandardFieldProps<CheckboxGroupProps>;
+export type FormRadioProps = OptionalField<CheckedFieldProps<RadioProps>>;
+export type FormRadioGroupProps = StandardFieldProps<RadioGroupProps>;
+export type FormDatePickerProps = StandardFieldProps<DatePickerProps>;
+export type FormSwitchProps = CheckedFieldProps<SwitchProps>;
+export type FormSliderProps = StandardFieldProps<SliderProps>;
+export type FormTimePickerProps = StandardFieldProps<TimePickerProps>;
+export type FormTreeSelectProps = StandardFieldProps<TreeSelectProps>;
+export type FormCascaderProps = StandardFieldProps<CascaderProps>;
+export type FormRatingProps = StandardFieldProps<RatingProps>;
+export type FormAutoCompleteProps = StandardFieldProps<AutoCompleteProps>;
+export type FormUploadProps = UploadFieldProps<UploadProps>;
+export type FormTagInputProps = StandardFieldProps<TagInputProps>;
+export type FormPinCodeProps = StandardFieldProps<PinCodeProps>;
+export interface FormSectionProps {
+    className?: HTMLAttributes['class'];
+    style?: CSSProperties;
+    text?: VNodeChild;
+}
+export interface FormSlotComponentProps {
+    className?: HTMLAttributes['class'];
+    label?: FormLabelProps | VNodeChild;
+    style?: CSSProperties;
+}
+export interface FormInputGroupProps extends Omit<InputGroupProps, 'label'> {
+    extraText?: VNodeChild;
+    extraTextPosition?: 'bottom' | 'middle';
+    label?: FormLabelProps | VNodeChild;
+    labelPosition?: 'left' | 'top';
+}
+export interface ArrayFieldItem {
+    key: string;
+    field: string;
+    remove(): void;
+}
+export interface ArrayFieldSlotProps {
+    add(index?: number): string;
+    addWithInitValue(value: unknown, index?: number): void;
+    arrayFields: ArrayFieldItem[];
+}
+export interface ArrayFieldProps {
+    field: string;
+    initValue?: unknown[];
+}
+export interface ArrayFieldSlots {
+    default?: (props: ArrayFieldSlotProps) => VNodeChild;
+}
+export interface FormUseResult<Values extends Record<string, unknown>> {
+    0: FormApi<Values>;
+    1: Ref<FormState<Values>>;
+    2: ComputedRef<Values>;
+    length: 3;
+}
+export type FormFieldComponent<Props> = DefineComponent<Props>;
+export interface WithFieldOptions {
+    maintainCursor?: boolean;
+    onUpdateEvent?: string;
+    valueProp?: string;
+    valuePath?: string;
+}
+export type WithField = <Props extends Record<string, unknown>>(component: Component, options?: WithFieldOptions) => FormFieldComponent<Props & CommonFieldProps>;
+export type FormComponentPublicInstance = ComponentPublicInstance<FormProps>;
+export {};

package/dist/form/use-form.d.ts

@@ -0,0 +1,11 @@
+import { ComputedRef, Ref } from 'vue';
+import { FieldApi, FormApi, FormState } from './types';
+export declare function useForm<Values extends Record<string, unknown> = Record<string, unknown>>(): readonly [FormApi<Values>, Ref<FormState<Values>>, ComputedRef<Values>];
+export declare function useFormApi<Values extends Record<string, unknown> = Record<string, unknown>>(): FormApi<Values>;
+export declare function useFormState<Values extends Record<string, unknown> = Record<string, unknown>>(): Readonly<Ref<FormState<Values>>>;
+export declare function useFieldApi(field: string): FieldApi;
+export declare function useFieldState(field: string): ComputedRef<{
+    value: unknown;
+    error: unknown;
+    touched: unknown;
+}>;

package/dist/form/with-form.d.ts

@@ -0,0 +1,3 @@
+import { Component } from 'vue';
+export declare function withFormApi(component: Component): Component;
+export declare function withFormState(component: Component): Component;