@dazhicheng/ui 1.5.33 → 1.5.35

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/group-form/FieldRenderer.d.ts

@@ -0,0 +1,81 @@
+import { PropType, VNode } from 'vue';
+import { FormSchema } from '../types';
+/**
+ * @description 根据 virtual 标志选择 LazyFormField 或 FormField 渲染单个字段，
+ *   消除模板中重复的条件分支
+ * @property {Record<string, unknown>} fieldConfig - mergeFieldConfig 合并后的完整字段配置
+ * @property {FormSchema["rules"]} [rules] - 字段校验规则
+ * @property {boolean} [virtual] - 是否启用虚拟化（LazyFormField）
+ * @property {Element | null} [scrollElement] - 虚拟化滚动容器
+ * @property {string} [virtualRootMargin] - IntersectionObserver rootMargin
+ * @property {number} [virtualEstimateHeight] - 预估占位高度
+ */
+export declare const FieldRenderer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** mergeFieldConfig 合并后的完整字段配置 */
+    fieldConfig: {
+        type: PropType<Record<string, unknown>>;
+        required: true;
+    };
+    /** 字段校验规则 */
+    rules: {
+        type: PropType<FormSchema["rules"]>;
+        default: undefined;
+    };
+    /** 是否启用虚拟化 */
+    virtual: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 虚拟化滚动容器 */
+    scrollElement: {
+        type: PropType<Element | null>;
+        default: null;
+    };
+    /** IntersectionObserver rootMargin */
+    virtualRootMargin: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 预估占位高度（px） */
+    virtualEstimateHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => VNode, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** mergeFieldConfig 合并后的完整字段配置 */
+    fieldConfig: {
+        type: PropType<Record<string, unknown>>;
+        required: true;
+    };
+    /** 字段校验规则 */
+    rules: {
+        type: PropType<FormSchema["rules"]>;
+        default: undefined;
+    };
+    /** 是否启用虚拟化 */
+    virtual: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 虚拟化滚动容器 */
+    scrollElement: {
+        type: PropType<Element | null>;
+        default: null;
+    };
+    /** IntersectionObserver rootMargin */
+    virtualRootMargin: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 预估占位高度（px） */
+    virtualEstimateHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    rules: import('../types').FormSchemaRuleType | undefined;
+    virtual: boolean;
+    scrollElement: Element | null;
+    virtualRootMargin: string;
+    virtualEstimateHeight: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,49 @@
+import { GroupFormSchema, GroupFormSectionProps } from './types';
+/**
+ * @description 滚动到指定分组（通过 data-group-key 定位 DOM）。
+ *   滚动期间暂停 LazyFormField 渲染，滚动结束后才恢复，
+ *   避免途经字段挂载导致高度变化引起布局抖动
+ * @param {string} key 分组 key
+ */
+declare function scrollToGroup(key: string): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: any;
+    refs: {
+        scrollRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<GroupFormSectionProps, {
+    scrollToGroup: typeof scrollToGroup;
+    navItems: import('vue').ComputedRef<{
+        key: string;
+        title: string;
+    }[]>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<GroupFormSectionProps> & Readonly<{}>, {
+    scrollToFirstError: boolean;
+    commonConfig: import('../types').FormCommonConfig;
+    compact: boolean;
+    layout: import('../types').FormLayout;
+    virtual: boolean;
+    containerHeight: number | string;
+    rootMargin: string;
+    estimateFieldHeight: number;
+    showNav: boolean;
+    navTitle: string;
+    autoScrollToGroup: import('./types').AutoScrollPosition;
+    groupSchema: GroupFormSchema[];
+    errorCacheMap: Map<string, string>;
+    resetSignal: import('vue').Ref<number>;
+    navErrorCounts: Record<string, number>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    scrollRef: HTMLDivElement;
+}, 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/group-form/GroupSection.vue.d.ts

@@ -0,0 +1,25 @@
+import { GroupSectionProps } from './types';
+declare function __VLS_template(): any;
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<GroupSectionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    toggleCollapse: (key: string) => any;
+}, string, import('vue').PublicProps, Readonly<GroupSectionProps> & Readonly<{
+    onToggleCollapse?: ((key: string) => any) | undefined;
+}>, {
+    commonConfig: import('../types').FormCommonConfig;
+    compact: boolean;
+    layout: string;
+    globalCommonConfig: import('../types').FormCommonConfig;
+    virtual: boolean;
+    scrollElement: Element | null;
+    virtualRootMargin: string;
+    virtualEstimateHeight: number;
+    depth: number;
+}, {}, {}, {}, 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/group-form/LazyFormField.vue.d.ts

@@ -0,0 +1,13 @@
+import { LazyFormFieldProps } from './types';
+declare const _default: import('vue').DefineComponent<LazyFormFieldProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LazyFormFieldProps> & Readonly<{}>, {
+    rules: import('../types').FormSchemaRuleType;
+    rootMargin: string;
+    fieldClass: string;
+    root: Element | null;
+    estimateHeight: number;
+    skeleton: boolean;
+    skeletonAnimated: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+}, any>;
+export default _default;

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

@@ -0,0 +1,3 @@
+export { useGroupForm } from './useGroupForm';
+export type { FormGroupSchema, FormRowSchema, GroupFormSchema, UseGroupFormOptions } from './types';
+export { isGroupSchema, isRowSchema, isSlotSchema, extractFlatSchemas } from './utils';

package/dist/components/tt-form/src/group-form/lazyContext.d.ts

@@ -0,0 +1,37 @@
+import { InjectionKey, Ref } from 'vue';
+/**
+ * 共享的字段错误缓存 Map，key 为 fieldName，value 为错误信息。
+ * 由 VirtualGroupForm provide，LazyFormField inject。
+ * validate 时对未挂载字段的校验错误写入此 map，
+ * LazyFormField 挂载时从中读取并通过 setFieldError 恢复。
+ */
+export declare const VIRTUAL_ERROR_CACHE_KEY: InjectionKey<Map<string, string>>;
+/**
+ * 重置信号（递增计数器），resetForm / resetValidate 时 +1。
+ * LazyFormField watch 此值来清空自身 cachedError。
+ */
+export declare const VIRTUAL_RESET_SIGNAL_KEY: InjectionKey<Ref<number>>;
+/**
+ * @description 分批渲染调度器，所有 LazyFormField 共享同一个实例。
+ *   滚动停稳后，视口内的字段排队请求渲染，调度器每帧只处理有限数量，
+ *   避免一次性挂载大量 FormField 导致主线程阻塞。
+ */
+export interface RenderScheduler {
+    /**
+     * @description 请求渲染一个字段，返回取消函数
+     * @param {() => void} callback - 渲染回调（设置 isVisible = true）
+     * @returns {() => void} 取消函数，字段离开视口时调用
+     */
+    request: (callback: () => void) => () => void;
+    /** @description 暂停调度（滚动跳转期间调用，防止途经字段挂载导致高度抖动） */
+    pause: () => void;
+    /** @description 恢复调度并处理队列中积压的请求 */
+    resume: () => void;
+}
+/**
+ * @description 创建分批渲染调度器
+ * @param {number} [batchSize=4] - 每帧最多渲染的字段数
+ * @returns {RenderScheduler} 调度器实例
+ */
+export declare function createRenderScheduler(batchSize?: number): RenderScheduler;
+export declare const RENDER_SCHEDULER_KEY: InjectionKey<RenderScheduler>;

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

@@ -0,0 +1,147 @@
+import { ExtendedFormApi, FormActions, FormCommonConfig, FormLayout, FormSchema, FormSlotSchema, TtFormProps, WrapperClassType } from '../types';
+import { Ref } from 'vue';
+export type CollapsibleType = boolean | ((values: Record<string, any>, actions: FormActions) => boolean | PromiseLike<boolean>);
+/** 控制 group / row / slot 是否显示，支持布尔值或函数（接收表单值与 formActions，可返回 Promise） */
+export type IfShowConditionType = boolean | ((values: Record<string, any>, actions: FormActions) => boolean | PromiseLike<boolean>);
+/** 分组表单项 */
+export interface FormGroupSchema {
+    /** 类型 */
+    type: "group";
+    /** 分组唯一标识 */
+    key: string;
+    /** 分组标题 */
+    title: string;
+    /** 是否可折叠，支持布尔值或函数 (values, actions) => boolean | Promise<boolean> */
+    collapsible?: CollapsibleType;
+    /** 初始是否折叠 */
+    defaultCollapsed?: boolean;
+    /** 子项（字段或嵌套分组） */
+    children: GroupFormSchema[];
+    /** 组内字段栅格布局 */
+    wrapperClass?: WrapperClassType;
+    /** 组内字段通用配置（覆盖外层 commonConfig） */
+    commonConfig?: FormCommonConfig;
+    /** 是否显示，支持布尔值或函数 (values, actions) => boolean | Promise<boolean>，默认 true */
+    ifShow?: IfShowConditionType;
+}
+/**
+ * 纯布局行容器，不产生分组标题，仅将若干字段包裹在一行内并支持自定义样式
+ * @property {"row"} type - 固定为 "row"
+ * @property {FormSchema[]} children - 行内字段列表
+ * @property {WrapperClassType} [wrapperClass] - 行容器额外 class（如 grid-cols-3、bg-xxx 等）
+ */
+export interface FormRowSchema {
+    /** 类型标识 */
+    type: "row";
+    /** 行内字段列表 */
+    children: FormSchema[];
+    /** 行容器额外 class，可用于设置列数、背景、圆角等 */
+    wrapperClass?: WrapperClassType;
+    /** 是否显示，支持布尔值或函数 (values, actions) => boolean | Promise<boolean>，默认 true */
+    ifShow?: IfShowConditionType;
+}
+export type GroupFormSchema = FormGroupSchema | FormRowSchema | FormSlotSchema | FormSchema;
+/** 分组表单组件选项 */
+export interface UseGroupFormOptions extends Omit<TtFormProps, "schema" | "showDefaultActions"> {
+    schema: GroupFormSchema[];
+    /** 是否启用表单项级别的虚拟化（IntersectionObserver 懒渲染），默认 true */
+    virtual?: boolean;
+    /** 滚动容器高度，默认 '100%' */
+    containerHeight?: number | string;
+    /** IntersectionObserver rootMargin，控制提前渲染的距离，默认 '200px 0px'（仅 virtual 为 true 时生效） */
+    rootMargin?: string;
+    /** 预估每个表单项高度（px），用于占位，默认 52（仅 virtual 为 true 时生效） */
+    estimateFieldHeight?: number;
+    /** 是否显示悬浮导航锚点，默认 true */
+    showNav?: boolean;
+    /** 导航栏标题，默认 '导航' */
+    navTitle?: string;
+    /** 自动滚动到指定分组，默认 'top' */
+    autoScrollToGroup?: AutoScrollPosition;
+    /** 校验失败时是否自动滚动到第一个有错误的分组，默认 true */
+    scrollToFirstError?: boolean;
+}
+/** LazyFormField 组件 props */
+export interface LazyFormFieldProps {
+    /** 传给 FormField 的完整 props（通过 v-bind 透传） */
+    fieldProps: Record<string, unknown>;
+    /** FormSchema.rules */
+    rules?: FormSchema["rules"];
+    /** FormSchema.formItemClass（用于外层 class） */
+    fieldClass?: string;
+    /** 滚动容器选择器或元素引用，默认取最近的 overflow:auto 祖先 */
+    root?: Element | null;
+    /** IntersectionObserver rootMargin，控制提前渲染的距离 */
+    rootMargin?: string;
+    /** 预估占位高度（px），首次渲染前使用 */
+    estimateHeight?: number;
+    /** 未进入视口时是否显示骨架屏（弹框首屏等场景减少白屏感），默认 true */
+    skeleton?: boolean;
+    /** 骨架屏是否开启动画，默认 true */
+    skeletonAnimated?: boolean;
+}
+/** 分组表单组件 props */
+export interface GroupFormSectionProps {
+    /** 分组表单定义（可选，优先从 store 读取） */
+    groupSchema?: GroupFormSchema[];
+    /** 表单 API */
+    formApi: ExtendedFormApi;
+    /** 分组折叠状态 */
+    collapseStates: Record<string, boolean>;
+    /** 滚动容器高度 */
+    containerHeight?: number | string;
+    /** 通用配置 */
+    commonConfig?: FormCommonConfig;
+    /** 布局 */
+    layout?: FormLayout;
+    /** 紧凑模式 */
+    compact?: boolean;
+    /** IntersectionObserver rootMargin，控制提前渲染距离 */
+    rootMargin?: string;
+    /** 预估每个表单项高度（px） */
+    estimateFieldHeight?: number;
+    /** 是否启用表单项级别的虚拟化，默认 true */
+    virtual?: boolean;
+    /** 共享的字段错误缓存，由 useGroupForm 创建 */
+    errorCacheMap?: Map<string, string>;
+    /** 重置信号，由 useGroupForm 创建 */
+    resetSignal?: Ref<number>;
+    /** 是否显示悬浮导航 */
+    showNav?: boolean;
+    /** 导航标题 */
+    navTitle?: string;
+    /** 导航各分组错误数量 */
+    navErrorCounts?: Record<string, number>;
+    /** 自动滚动到指定分组 */
+    autoScrollToGroup?: AutoScrollPosition;
+    /** 校验失败时是否自动滚动到第一个有错误的分组，默认 true */
+    scrollToFirstError?: boolean;
+    /** 切换分组折叠状态 */
+    toggleCollapse?: (key: string) => void;
+}
+/** GroupSection 递归组件 props */
+export interface GroupSectionProps {
+    /** 当前节点的 schema（分组 / 行容器 / 字段） */
+    schema: GroupFormSchema;
+    /** 分组折叠状态 */
+    collapseStates: Record<string, boolean>;
+    /** 当前层级合并后的通用配置 */
+    commonConfig?: FormCommonConfig;
+    /** 全局通用配置（最外层传入，逐层透传） */
+    globalCommonConfig?: FormCommonConfig;
+    /** 表单布局方向 */
+    layout?: string;
+    /** 紧凑模式 */
+    compact?: boolean;
+    /** 当前嵌套深度，顶层为 0，递归时自增 */
+    depth?: number;
+    /** 是否启用表单项级别的虚拟化（IntersectionObserver 懒渲染） */
+    virtual?: boolean;
+    /** 虚拟化时滚动容器引用 */
+    scrollElement?: Element | null;
+    /** 虚拟化时 IntersectionObserver rootMargin */
+    virtualRootMargin?: string;
+    /** 虚拟化时预估表单项高度（px） */
+    virtualEstimateHeight?: number;
+}
+export type AutoScrollPosition = "top" | "bottom";

package/dist/components/tt-form/src/group-form/useGroupForm.d.ts

@@ -0,0 +1,5 @@
+import { ExtendedFormApi } from '../types';
+import { UseGroupFormOptions } from './types';
+export declare function useGroupForm(options: UseGroupFormOptions): readonly [import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, ExtendedFormApi, Record<string, boolean>];

package/dist/components/tt-form/src/group-form/utils.d.ts

@@ -0,0 +1,93 @@
+import { FormGroupSchema, FormRowSchema, GroupFormSchema } from './types';
+import { FormSchema, FormSlotSchema } from '../types';
+/**
+ * 判断当前节点是否为分组 schema（含 type: 'group' 与 children）
+ * @param {GroupFormSchema} schema - 分组表单 schema 节点（分组或字段）
+ * @returns {boolean} 若为分组则 true，且类型收窄为 FormGroupSchema
+ * @example
+ * if (isGroupSchema(item)) item.children; // 可安全访问 children
+ */
+export declare function isGroupSchema(schema: GroupFormSchema): schema is FormGroupSchema;
+/**
+ * 判断当前节点是否为纯布局行容器（type: 'row'）
+ * @param {GroupFormSchema} schema - 分组表单 schema 节点
+ * @returns {boolean} 若为行容器则 true，且类型收窄为 FormRowSchema
+ * @example
+ * if (isRowSchema(item)) item.children; // 可安全访问 children（均为字段）
+ */
+export declare function isRowSchema(schema: GroupFormSchema): schema is FormRowSchema;
+/**
+ * 判断当前节点是否为自定义插槽（type: 'slot'）
+ * @param {GroupFormSchema} schema - 分组表单 schema 节点
+ * @returns {boolean} 若为插槽则 true，且类型收窄为 FormSlotSchema
+ * @example
+ * if (isSlotSchema(item)) console.log(item.content);
+ */
+export declare function isSlotSchema(schema: GroupFormSchema): schema is FormSlotSchema;
+/**
+ * 递归展平分组 schema，提取所有字段 schema（忽略分组结构）
+ * @param {GroupFormSchema[]} schemas - 分组 schema 数组，可包含分组与字段的混合结构
+ * @returns {FormSchema[]} 展平后的字段 schema 数组，不包含分组节点
+ * @example
+ * const flat = extractFlatSchemas([
+ *   { type: 'group', key: 'basic', children: [{ fieldName: 'name' }] },
+ *   { fieldName: 'age' }
+ * ]);
+ * // 返回: [{ fieldName: 'name' }, { fieldName: 'age' }]
+ */
+export declare function extractFlatSchemas(schemas: GroupFormSchema[]): FormSchema[];
+/**
+ * 递归收集分组 schema 中 defaultCollapsed 为 true 的分组 key，写入 states
+ * @param {GroupFormSchema[]} schemas - 分组表单 schema 数组
+ * @param {Record<string, boolean>} states - 折叠状态对象，按分组 key 写入 true 表示初始折叠
+ * @example
+ * const states = {}; collectDefaultCollapseStates(groupSchema, states);
+ */
+export declare function collectDefaultCollapseStates(schemas: any[], states: Record<string, boolean>): void;
+/**
+ * 插入位置描述
+ * @property {string} [before] - 在匹配节点之前插入（匹配 fieldName / slot content / group key）
+ * @property {string} [after] - 在匹配节点之后插入（匹配规则同 before）
+ */
+export interface InsertPosition {
+    before?: string;
+    after?: string;
+}
+/**
+ * 在 groupSchema 树中查找指定 groupKey 的分组，并在其 children 中插入新字段。
+ * 当 before/after 匹配到 row 内部的字段时，会直接在 row 的 children 中插入
+ * @param {GroupFormSchema[]} schemas - 分组 schema 树（会被原地修改）
+ * @param {string} groupKey - 目标分组的 key
+ * @param {GroupFormSchema[]} fields - 要插入的字段
+ * @param {InsertPosition} [position] - 插入位置；省略则追加到末尾
+ * @returns {boolean} 是否找到目标分组并完成插入
+ * @example
+ * // 在 fieldName 为 'phone' 的字段之前插入
+ * insertFieldsInGroup(schema, 'contact', [newField], { before: 'phone' });
+ * @example
+ * // 在 row 内部的 'v_age' 字段之后插入
+ * insertFieldsInGroup(schema, 'basic', [newField], { after: 'v_age' });
+ */
+export declare function insertFieldsInGroup(schemas: GroupFormSchema[], groupKey: string, fields: GroupFormSchema[], position?: InsertPosition): boolean;
+/**
+ * 从 groupSchema 树中递归移除指定 fieldName 或 slot content 的节点
+ * @param {GroupFormSchema[]} schemas - 分组 schema 树（会被原地修改）
+ * @param {Set<string>} fieldNames - 要移除的标识集合（fieldName 或 slot content 字符串）
+ * @returns {GroupFormSchema[]} 过滤后的 schema 数组
+ * @example
+ * removeFieldsFromGroup(schema, new Set(['phone_0', 'divider-contact-0']));
+ */
+export declare function removeFieldsFromGroup(schemas: GroupFormSchema[], fieldNames: Set<string>): GroupFormSchema[];
+/**
+ * 浅拷贝 groupSchema 树结构（只复制数组和分组/行的 children 引用，不深拷贝叶子节点）
+ * @param {GroupFormSchema[]} schemas - 原始 schema 树
+ * @returns {GroupFormSchema[]} 拷贝后的新树，可安全做 splice 等原地修改而不影响原树
+ */
+export declare function cloneSchemaTree(schemas: GroupFormSchema[]): GroupFormSchema[];
+/**
+ * 获取分组 schema 的值
+ * @param {GroupFormSchema[]} groupSchema - 分组 schema 数组（可含 group / row / slot / 字段）
+ * @param {Record<string, any>} values - 表单值
+ * @returns {Record<string, any>} 分组值
+ */
+export declare function getGroupValues(groupSchema: GroupFormSchema[], values: Record<string, any>): Record<string, any>;

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';