@dazhicheng/ui 1.5.32 → 1.5.34

package/dist/components/tt-form/src/formApi.d.ts

@@ -0,0 +1,71 @@
+import { FormState, GenericObject, ResetFormOpts, ValidationOptions } from 'vee-validate';
+import { ComponentPublicInstance } from 'vue';
+import { Recordable, StateHandler } from '../../../../../utils/src';
+import { FormActions, FormSchema, TtFormProps } from './types';
+import { Store } from './shared/store';
+export declare class FormApi {
+    form: FormActions;
+    isMounted: boolean;
+    state: null | TtFormProps;
+    stateHandler: StateHandler;
+    store: Store<TtFormProps>;
+    /**
+     * 组件实例映射
+     */
+    private componentRefMap;
+    private latestSubmissionValues;
+    private prevState;
+    constructor(options?: TtFormProps);
+    /**
+     * 获取字段组件实例
+     * @param fieldName 字段名
+     * @returns 组件实例
+     */
+    getFieldComponentRef<T = ComponentPublicInstance>(fieldName: string): T | undefined;
+    /**
+     * 获取当前聚焦的字段，如果没有聚焦的字段则返回undefined
+     */
+    getFocusedField(): string | undefined;
+    getLatestSubmissionValues(): Recordable<any>;
+    getState(): TtFormProps<keyof import('./types').BaseFormComponentMap> | null;
+    getValues<T = Recordable<any>>(): Promise<T>;
+    isFieldValid(fieldName: string): Promise<boolean>;
+    merge(formApi: FormApi): any;
+    mount(formActions: FormActions, componentRefMap: Map<string, unknown>): void;
+    /**
+     * 根据字段名移除表单项
+     * @param fields
+     */
+    removeSchemaByFields(fields: string[]): Promise<void>;
+    /**
+     * 重置表单
+     */
+    resetForm(state?: Partial<FormState<GenericObject>> | undefined, opts?: Partial<ResetFormOpts>): Promise<void>;
+    resetValidate(): Promise<void>;
+    /**
+     * 滚动到第一个错误字段
+     * @param errors 验证错误对象
+     */
+    scrollToFirstError(errors: Record<string, any> | string): void;
+    setFieldValue(field: string, value: any, shouldValidate?: boolean): Promise<void>;
+    setLatestSubmissionValues(values: null | Recordable<any>): void;
+    setState(stateOrFn: ((prev: TtFormProps) => Partial<TtFormProps>) | Partial<TtFormProps>): void;
+    /**
+     * 设置表单值
+     * @param fields record
+     * @param filterFields 过滤不在schema中定义的字段 默认为true
+     * @param shouldValidate
+     */
+    setValues(fields: Record<string, any>, filterFields?: boolean, shouldValidate?: boolean): Promise<void>;
+    submitForm(e?: Event): Promise<Recordable<any>>;
+    unmount(): void;
+    updateSchema(schema: Partial<FormSchema>[]): void;
+    validate(opts?: Partial<ValidationOptions>): Promise<import('vee-validate').FormValidationResult<GenericObject, GenericObject>>;
+    validateAndSubmitForm(): Promise<Recordable<any> | undefined>;
+    validateField(fieldName: string, opts?: Partial<ValidationOptions>): Promise<import('vee-validate').ValidationResult<any>>;
+    private getForm;
+    private handleMultiFields;
+    private handleRangeTimeValue;
+    private processFields;
+    private updateState;
+}

package/dist/components/tt-form/src/hooks/useEmitAsProps.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `useEmitAsProps` 是一个 TypeScript 工具函数，用于将组件发出的事件转换为 props
+ * @param emit - `emit` 参数是一个用于从组件发出事件的函数
+ * 接收两个参数：`name` 是要发出的事件名称，`...args` 是随事件传递的参数
+ * @returns 返回一个对象，该对象将事件名称映射到调用 `emit` 函数的处理函数
+ */
+export declare function useEmitAsProps<Name extends string>(emit: (name: Name, ...args: any[]) => void): Record<string, any>;

package/dist/components/tt-form/src/hooks/useFormFieldBus.d.ts

@@ -0,0 +1,14 @@
+import { FormValidationResult } from '../types/forms';
+import { GenericObject } from '../types/common';
+/**
+ * Hook for form field event bus
+ * @param key - Optional custom key for the event bus, defaults to Symbol('FormField')
+ * @returns Event bus instance
+ */
+export declare function useFormFieldBus(key?: string | symbol): import('@vueuse/core').UseEventBusReturn<FormValidationResult<GenericObject, GenericObject>, any>;
+/**
+ * Hook for form filter event bus
+ * @param key - Optional custom key for the event bus, defaults to Symbol('FormFilter')
+ * @returns Event bus instance
+ */
+export declare function useFormFilterBus(key?: string | symbol): import('@vueuse/core').UseEventBusReturn<string, any>;

package/dist/components/tt-form/src/hooks/useForwardPriorityValues.d.ts

@@ -0,0 +1,14 @@
+import { ComputedRef, Ref } from 'vue';
+/**
+ * 依次从插槽、attrs、props、state 中获取值
+ * @param key
+ * @param props
+ * @param state
+ */
+export declare function usePriorityValue<T extends Record<string, any>, S extends Record<string, any>, K extends keyof T = keyof T>(key: K, props: T, state: Readonly<Ref<NoInfer<S>>> | undefined): ComputedRef<T[K]>;
+/**
+ * 批量获取state中的值（集中在一个computed，用于透传）
+ * @param props
+ * @param state
+ */
+export declare function useForwardPriorityValues<T extends Record<string, any>, S extends Ref<Record<string, any>> = Readonly<Ref<NoInfer<T>, NoInfer<T>>>>(props: T, state: S | undefined): ComputedRef<{ [K in keyof T]: T[K]; }>;

package/dist/components/tt-form/src/hooks/useForwardProps.d.ts

@@ -0,0 +1,7 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * `useForwardProps` 函数接收一组 props 并返回一个计算值，该值合并了当前实例的默认 props 和传入的 props。
+ * @param {T} props - `props` 参数是一个对象，表示传递给组件的 props。
+ * @returns 返回一个计算值，合并了默认 props、保留的 props 和传入的 props。
+ */
+export declare function useForwardProps<T extends Record<string, any>>(props: MaybeRefOrGetter<T>): import('vue').ComputedRef<T>;

package/dist/components/tt-form/src/hooks/useForwardPropsEmits.d.ts

@@ -0,0 +1,8 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * 函数 `useForwardPropsEmits` 接收 props 和可选的 emit 函数，返回一个计算属性对象，该对象合并了解析后的 props 和 emits。
+ * @param {T} props - `props` 参数类型为 `T`，是扩展自 `useForwardProps` 函数参数的泛型类型。表示传递给 `useForwardProps` 函数的 props 对象。
+ * @param [emit] - `emit` 参数是一个可用于触发事件的函数。它接收两个参数：`name` 表示要触发的事件名称，`args` 是要随事件传递的参数。
+ * @returns 返回一个计算属性，合并了解析后的 props 和 emits。
+ */
+export declare function useForwardPropsEmits<T extends Record<string, any>, Name extends string>(props: MaybeRefOrGetter<T>, emit?: (name: Name, ...args: any[]) => void): import('vue').ComputedRef<T & Record<string, any>>;

package/dist/components/tt-form/src/index.vue.d.ts

@@ -0,0 +1,27 @@
+import { ExtendedFormApi, TtFormProps } from './types';
+interface Props extends TtFormProps {
+    formApi?: ExtendedFormApi;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: any) => any>> & {
+        default?(_: {
+            shapes: import('./types').FormShape[];
+        }): any;
+        'reset-before'?(_: {}): any;
+        'submit-before'?(_: {}): any;
+        'expand-before'?(_: {}): any;
+        'expand-after'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tt-form/src/shared/createContext.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param providerComponentName - The name(s) of the component(s) providing the context.
+ *
+ * There are situations where context can come from multiple components. In such cases, you might need to give an array of component names to provide your context, instead of just a single string.
+ *
+ * @param contextName The description for injection key symbol.
+ */
+export declare function createContext<ContextValue>(providerComponentName: string | string[], contextName?: string): readonly [<T extends ContextValue | null | undefined = ContextValue>(fallback?: T) => T extends null ? ContextValue | null : ContextValue, (contextValue: ContextValue) => ContextValue];

package/dist/components/tt-form/src/shared/global-state.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 全局复用的变量、组件、配置，各个模块之间共享
+ * 通过单例模式实现,单例必须注意不受请求影响，例如用户信息这些需要根据请求获取的。后续如果有ssr需求，也不会影响
+ */
+interface ComponentsState {
+    [key: string]: any;
+}
+export interface IGlobalSharedState {
+    components: ComponentsState;
+}
+declare class GlobalShareState {
+    #private;
+    getComponents(): ComponentsState;
+    setComponents(value: ComponentsState): void;
+}
+export declare const globalShareState: GlobalShareState;
+export {};

package/dist/components/tt-form/src/shared/store.d.ts

@@ -0,0 +1 @@
+export * from '@tanstack/vue-store';

package/dist/components/tt-form/src/shared/zod-defaults.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+/**
+ * A type which represents all the simple Zod types
+ * that do not require special handling.
+ */
+export type SimpleSupportedZodTypes = z.ZodBoolean | z.ZodNumber | z.ZodString | z.ZodArray<any>;
+/**
+ * A type which represents all the supported Zod types
+ * that do not require special handling.
+ *
+ * Other special types like ZodUnion, ZodIntersection, etc.
+ * require special handling and are not included in this type.
+ *
+ * TODO: Add support for missing Zod types.
+ */
+export type BaseSupportedZodTypes = SimpleSupportedZodTypes | z.ZodRecord<any, any> | z.ZodObject<any, any> | z.ZodTuple<[any, ...any[]]>;
+/**
+ * A type which represents all the supported Zod types
+ * that require special handling because they are composed
+ * of multiple Zod types.
+ *
+ * TODO: Add support for missing Zod types.
+ */
+export type AdvancedSupportedZodTypes = z.ZodDefault<any> | z.ZodOptional<any> | z.ZodUnion<any> | z.ZodIntersection<any, any>;
+/**
+ * A type which represents all the supported Zod types.
+ */
+export type SupportedZodTypes = BaseSupportedZodTypes | AdvancedSupportedZodTypes;
+/**
+ * Returns the default values as an object for the provided schema.
+ *
+ * For example, given the following schema:
+ * ```typescript
+ * const schema = z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ *   isStudent: z.boolean().default(true),
+ * });
+ * ```
+ *
+ * The default object would be:
+ * ```json
+ * {
+ *   name: "",
+ *   age: 0,
+ *   isStudent: true
+ * }
+ * ```
+ * Note the default value for `isStudent` is `true` because it is specified in
+ * the schema.
+ *
+ * @param schema
+ */
+export declare function getDefaultsForSchema<T extends z.ZodObject<any> | z.ZodUnion<any> | z.ZodIntersection<any, any>>(schema: T): Record<string, never> | z.infer<T>;

package/dist/components/tt-form/src/types/common.d.ts

@@ -0,0 +1,11 @@
+import { MaybeRef, Ref } from 'vue';
+import { Path, PathValue } from './paths';
+export type GenericObject = Record<string, any>;
+export type MaybeArray<T> = T | T[];
+export type MaybePromise<T> = T | Promise<T>;
+export type FlattenAndSetPathsType<TRecord, TType> = {
+    [K in Path<TRecord>]: TType;
+};
+export type MapValuesPathsToRefs<TValues extends GenericObject, TPaths extends readonly [...MaybeRef<Path<TValues>>[]]> = {
+    readonly [K in keyof TPaths]: TPaths[K] extends MaybeRef<infer TKey> ? TKey extends Path<TValues> ? Ref<PathValue<TValues, TKey>> : Ref<unknown> : Ref<unknown>;
+};

package/dist/components/tt-form/src/types/forms.d.ts

@@ -0,0 +1,280 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { PartialDeep } from 'type-fest';
+import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
+import { FlattenAndSetPathsType, GenericObject, MapValuesPathsToRefs, MaybeArray, MaybePromise } from './common';
+import { Path, PathValue } from './paths';
+import { FieldValidationMetaInfo } from './shared';
+export type ValidationResult<TValue = unknown> = {
+    errors: string[];
+    valid: boolean;
+    value?: TValue;
+};
+export type FlattenAndMapPathsValidationResult<TInput extends GenericObject, TOutput extends GenericObject> = {
+    [K in Path<TInput>]: ValidationResult<TOutput[K]>;
+};
+export type Locator = {
+    __locatorRef: string;
+} & ((values: GenericObject) => unknown);
+export interface FieldMeta<TValue> {
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    validated: boolean;
+    pending: boolean;
+    initialValue?: TValue;
+}
+export interface FormMeta<TValues extends GenericObject> {
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    pending: boolean;
+    initialValues?: Partial<TValues>;
+}
+export interface FieldState<TValue = unknown> {
+    value: TValue;
+    touched: boolean;
+    errors: string[];
+}
+export type InputType = "checkbox" | "radio" | "default";
+/**
+ * validated-only: only mutate the previously validated fields
+ * silent: do not mutate any field
+ * force: validate all fields and mutate their state
+ */
+export type SchemaValidationMode = "validated-only" | "silent" | "force" | "no-validated";
+export type ValidationOptions = {
+    mode: SchemaValidationMode;
+    warn: boolean;
+};
+export type FieldValidator<TOutput> = (opts?: Partial<ValidationOptions>) => Promise<ValidationResult<TOutput>>;
+export type PathStateConfig<TOutput> = {
+    bails: boolean;
+    label: MaybeRefOrGetter<string | undefined>;
+    type: InputType;
+    validate: FieldValidator<TOutput>;
+    schema?: MaybeRefOrGetter<StandardSchemaV1 | undefined>;
+    /**
+     * 在判断 dirty 状态时需要排除的字段列表（仅对对象类型有效）
+     * @example
+     * excludeKeys: ['_timestamp']
+     */
+    excludeKeys?: string[];
+};
+export type IssueCollection<TPath = string> = {
+    path: TPath;
+    messages: string[];
+};
+export type PathState<TInput = unknown, TOutput = TInput> = {
+    id: number | number[];
+    path: string;
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    validated: boolean;
+    pending: boolean;
+    initialValue: TInput | undefined;
+    value: TInput | undefined;
+    errors: string[];
+    bails: boolean;
+    label: string | undefined;
+    type: InputType;
+    multiple: boolean;
+    fieldsCount: number;
+    __flags: {
+        pendingUnmount: Record<string, boolean>;
+        pendingReset: boolean;
+    };
+    validate?: FieldValidator<TOutput>;
+};
+export type FieldEntry<TValue = unknown> = {
+    value: TValue;
+    key: string | number;
+    isFirst: boolean;
+    isLast: boolean;
+};
+export type FieldArrayContext<TValue = unknown> = {
+    fields: Ref<FieldEntry<TValue>[]>;
+    remove: (idx: number) => void;
+    replace: (newArray: TValue[]) => void;
+    update: (idx: number, value: TValue) => void;
+    push: (value: TValue) => void;
+    swap: (indexA: number, indexB: number) => void;
+    insert: (idx: number, value: TValue) => void;
+    prepend: (value: TValue) => void;
+    move: (oldIdx: number, newIdx: number) => void;
+};
+export type PrivateFieldArrayContext<TValue = unknown> = {
+    reset: () => void;
+    path: MaybeRefOrGetter<string>;
+} & FieldArrayContext<TValue>;
+export type PrivateFieldContext<TInput = unknown, TOutput = TInput> = {
+    id: number;
+    name: MaybeRef<string>;
+    value: Ref<TInput>;
+    meta: FieldMeta<TInput>;
+    errors: Ref<string[]>;
+    errorMessage: Ref<string | undefined>;
+    label?: MaybeRefOrGetter<string | undefined>;
+    type?: string;
+    bails?: boolean;
+    keepValueOnUnmount?: MaybeRefOrGetter<boolean | undefined>;
+    checkedValue?: MaybeRefOrGetter<TInput>;
+    uncheckedValue?: MaybeRefOrGetter<TInput>;
+    checked?: Ref<boolean>;
+    resetField: (state?: Partial<FieldState<TInput>>) => void;
+    handleReset: () => void;
+    validate: FieldValidator<TOutput>;
+    handleChange: (e: Event | unknown, shouldValidate?: boolean) => void;
+    handleBlur: (e?: Event, shouldValidate?: boolean) => void;
+    handleFocus: (e?: Event) => void;
+    setState: (state: Partial<FieldState<TInput>>) => void;
+    setTouched: (isTouched: boolean) => void;
+    setErrors: (message: string | string[]) => void;
+    setValue: (value: TInput, shouldValidate?: boolean) => void;
+};
+export type FieldContext<TValue = unknown> = Omit<PrivateFieldContext<TValue>, "id" | "instances">;
+export type GenericValidateFunction<TValue = unknown> = (value: TValue, ctx: FieldValidationMetaInfo) => MaybePromise<boolean | MaybeArray<string>>;
+export interface FormState<TValues> {
+    values: PartialDeep<TValues>;
+    errors: Partial<Record<Path<TValues>, string | undefined>>;
+    touched: Partial<Record<Path<TValues>, boolean>>;
+    submitCount: number;
+}
+export type FormErrors<TValues extends GenericObject> = Partial<Record<Path<TValues> | "", string | undefined>>;
+export type FormErrorBag<TValues extends GenericObject> = Partial<Record<Path<TValues> | "", string[]>>;
+export interface ResetFormOpts {
+    force?: boolean;
+}
+export interface FormActions<TValues extends GenericObject, _TOutput = TValues> {
+    setFieldValue: <T extends Path<TValues>>(field: T, value: PathValue<TValues, T>, shouldValidate?: boolean) => void;
+    setFieldError: (field: Path<TValues>, message: string | string[] | undefined) => void;
+    setErrors: (fields: Partial<FlattenAndSetPathsType<TValues, string | string[] | undefined>>) => void;
+    setValues: (fields: Partial<TValues>, shouldValidate?: boolean) => void;
+    setFieldTouched: (field: Path<TValues>, isTouched: boolean) => void;
+    setTouched: (fields: Partial<Record<Path<TValues>, boolean>> | boolean) => void;
+    resetForm: (state?: Partial<FormState<TValues>>, opts?: Partial<ResetFormOpts>) => void;
+    resetField: (field: Path<TValues>, state?: Partial<FieldState>) => void;
+}
+export interface FormValidationResult<TInput extends GenericObject, TOutput extends GenericObject = TInput> {
+    valid: boolean;
+    results: Partial<FlattenAndMapPathsValidationResult<TInput, TOutput>>;
+    errors: Partial<Record<Path<TInput>, string>>;
+    values?: Partial<TOutput>;
+    source: "schema" | "fields" | "none";
+}
+export interface SubmissionContext<TInput extends GenericObject = GenericObject> extends FormActions<TInput> {
+    evt?: Event;
+    controlledValues: Partial<TInput>;
+}
+export type SubmissionHandler<TInput extends GenericObject = GenericObject, TOutput = TInput, TReturn = unknown> = (values: TOutput, ctx: SubmissionContext<TInput>) => TReturn;
+export interface InvalidSubmissionContext<TInput extends GenericObject = GenericObject, TOutput extends GenericObject = TInput> {
+    values: TInput;
+    evt?: Event;
+    errors: Partial<Record<Path<TInput>, string>>;
+    results: FormValidationResult<TInput, TOutput>["results"];
+}
+export type InvalidSubmissionHandler<TInput extends GenericObject = GenericObject, TOutput extends GenericObject = TInput> = (ctx: InvalidSubmissionContext<TInput, TOutput>) => void;
+export type RawFormSchema<TValues> = Record<Path<TValues>, string | GenericValidateFunction | GenericObject>;
+export type FieldPathLookup<TValues extends GenericObject = GenericObject> = Partial<Record<Path<TValues>, PrivateFieldContext | PrivateFieldContext[]>>;
+type HandleSubmitFactory<TValues extends GenericObject, TOutput extends GenericObject = TValues> = <TReturn = unknown>(cb: SubmissionHandler<TValues, TOutput, TReturn>, onSubmitValidationErrorCb?: InvalidSubmissionHandler<TValues, TOutput>) => (e?: Event) => Promise<TReturn | undefined>;
+export type PublicPathState<TValue = unknown> = Omit<PathState<TValue>, "bails" | "label" | "multiple" | "fieldsCount" | "validate" | "id" | "type" | "__flags">;
+export interface BaseFieldProps {
+    onBlur: () => void;
+    onChange: () => void;
+    onInput: () => void;
+}
+export interface InputBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> {
+    props: (state: PublicPathState<TValue>) => TExtraProps;
+    validateOnBlur: boolean;
+    label: MaybeRefOrGetter<string>;
+    validateOnChange: boolean;
+    validateOnInput: boolean;
+    validateOnModelUpdate: boolean;
+}
+export type LazyInputBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> = (state: PublicPathState<TValue>) => Partial<{
+    props: TExtraProps;
+    validateOnBlur: boolean;
+    validateOnChange: boolean;
+    validateOnInput: boolean;
+    validateOnModelUpdate: boolean;
+}>;
+export interface ComponentBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject, TModel extends string = "modelValue"> {
+    mapProps: (state: PublicPathState<TValue>) => TExtraProps;
+    validateOnBlur: boolean;
+    validateOnModelUpdate: boolean;
+    model: TModel;
+}
+export type LazyComponentBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject, TModel extends string = "modelValue"> = (state: PublicPathState<TValue>) => Partial<{
+    props: TExtraProps;
+    validateOnBlur: boolean;
+    validateOnModelUpdate: boolean;
+    model: TModel;
+}>;
+export interface ComponentModellessBinds {
+    onBlur: () => void;
+}
+export type ComponentModelBinds<TValue = any, TModel extends string = "modelValue"> = ComponentModellessBinds & {
+    [TKey in `onUpdate:${TModel}`]: (value: TValue) => void;
+};
+export type BaseComponentBinds<TValue = any, TModel extends string = "modelValue"> = ComponentModelBinds<TValue, TModel> & {
+    [k in TModel]: TValue;
+};
+export interface BaseInputBinds<TValue = unknown> {
+    value: TValue | undefined;
+    onBlur: (e: Event) => void;
+    onChange: (e: Event) => void;
+    onInput: (e: Event) => void;
+}
+export interface PrivateFormContext<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues> extends FormActions<TValues> {
+    name: string;
+    formId: number;
+    values: TValues;
+    initialValues: Ref<Partial<TValues>>;
+    controlledValues: Ref<TValues>;
+    fieldArrays: PrivateFieldArrayContext[];
+    submitCount: Ref<number>;
+    schema?: MaybeRef<RawFormSchema<TValues> | StandardSchemaV1<TValues, TOutput> | undefined>;
+    errorBag: Ref<FormErrorBag<TValues>>;
+    errors: ComputedRef<FormErrors<TValues>>;
+    meta: ComputedRef<FormMeta<TValues>>;
+    isSubmitting: Ref<boolean>;
+    isValidating: Ref<boolean>;
+    keepValuesOnUnmount: MaybeRef<boolean>;
+    validateSchema?: (mode: SchemaValidationMode) => Promise<FormValidationResult<TValues, TOutput>>;
+    validate: (opts?: Partial<ValidationOptions>) => Promise<FormValidationResult<TValues, TOutput>>;
+    validateField: <TPath extends Path<TValues>>(field: TPath, opts?: Partial<ValidationOptions>) => Promise<ValidationResult<TOutput[TPath]>>;
+    stageInitialValue: (path: string, value: unknown, updateOriginal?: boolean) => void;
+    unsetInitialValue: (path: string) => void;
+    handleSubmit: HandleSubmitFactory<TValues, TOutput> & {
+        withControlled: HandleSubmitFactory<TValues, TOutput>;
+    };
+    setFieldInitialValue: (path: string, value: unknown, updateOriginal?: boolean) => void;
+    createPathState: <TPath extends Path<TValues>>(path: MaybeRef<TPath>, config?: Partial<PathStateConfig<TOutput[TPath]>>) => PathState<PathValue<TValues, TPath>>;
+    getPathState: <TPath extends Path<TValues>>(path: TPath) => PathState<PathValue<TValues, TPath>> | undefined;
+    getAllPathStates: () => PathState[];
+    removePathState: <TPath extends Path<TValues>>(path: TPath, id: number) => void;
+    unsetPathValue: <TPath extends Path<TValues>>(path: TPath) => void;
+    destroyPath: (path: string) => void;
+    isFieldTouched: <TPath extends Path<TValues>>(path: TPath) => boolean;
+    isFieldDirty: <TPath extends Path<TValues>>(path: TPath) => boolean;
+    isFieldValid: <TPath extends Path<TValues>>(path: TPath) => boolean;
+    defineField: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<InputBindsConfig<TValue, TExtras>> | LazyInputBindsConfig<TValue, TExtras>) => [Ref<TValue>, Ref<BaseFieldProps & TExtras>];
+    /**
+     * @deprecated use defineField instead
+     */
+    useFieldModel: (<TPath extends Path<TValues>>(path: TPath) => Ref<PathValue<TValues, TPath>>) & (<TPaths extends readonly [...MaybeRef<Path<TValues>>[]]>(paths: TPaths) => MapValuesPathsToRefs<TValues, TPaths>);
+    /**
+     * @deprecated use defineField instead
+     */
+    defineComponentBinds: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TModel extends string = "modelValue", TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<ComponentBindsConfig<TValue, TExtras, TModel>> | LazyComponentBindsConfig<TValue, TExtras, TModel>) => Ref<BaseComponentBinds<TValue, TModel> & TExtras>;
+    /**
+     * @deprecated use defineField instead
+     */
+    defineInputBinds: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<InputBindsConfig<TValue, TExtras>> | LazyInputBindsConfig<TValue, TExtras>) => Ref<BaseInputBinds<TValue> & TExtras>;
+}
+export interface FormContext<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues> extends Omit<PrivateFormContext<TValues, TOutput>, "formId" | "schema" | "initialValues" | "getPathState" | "getAllPathStates" | "removePathState" | "unsetPathValue" | "validateSchema" | "stageInitialValue" | "setFieldInitialValue" | "unsetInitialValue" | "fieldArrays" | "markForUnmount" | "keepValuesOnUnmount" | "values"> {
+    values: TValues;
+    handleReset: () => void;
+    submitForm: (e?: unknown) => Promise<void>;
+}
+export {};

package/dist/components/tt-form/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './forms';
+export * from './paths';