@movk/nuxt 1.2.0 → 1.3.0

package/dist/runtime/types/auto-form/base.d.ts

@@ -0,0 +1,26 @@
+import type { FormProps } from '@nuxt/ui';
+import type { z } from 'zod';
+import type { OmitByKey } from '@movk/core';
+import type { AutoFormControls } from './controls';
+import type { ZodAutoFormFieldMeta } from '../zod';
+import type { ClassNameValue } from '../shared';
+export interface BaseAutoFormProps<S extends z.ZodObject, T extends boolean = true, N extends boolean = false> extends /** @vue-ignore */ OmitByKey<FormProps<S, T, N>, 'schema' | 'state' | 'loadingAuto' | 'validateOn' | 'ui'> {
+    /** Zod 对象 schema，定义表单字段 */
+    schema: S;
+    /** 自定义控件映射 */
+    controls?: AutoFormControls;
+    /** 全局字段元数据配置 */
+    globalMeta?: ZodAutoFormFieldMeta;
+    /**
+     * 是否启用自动 loading 功能。
+     * @defaultValue true
+     */
+    loadingAuto?: FormProps<S, T, N>['loadingAuto'];
+    /**
+     * 表单验证时机，详见 UForm 的 validateOn 属性
+     * @defaultValue []
+     */
+    validateOn?: FormProps<S, T, N>['validateOn'];
+    class?: ClassNameValue;
+    ui?: Record<string, ClassNameValue>;
+}

package/dist/runtime/types/auto-form/component.d.ts

@@ -0,0 +1,28 @@
+import type { ButtonProps, FormProps, FormSubmitEvent, FormData, FormErrorEvent } from '@nuxt/ui';
+import type { z } from 'zod';
+import type { BaseAutoFormProps } from './base';
+import type { AutoFormSlotProps, DynamicFormSlots } from './slots';
+import type { VNode } from 'vue';
+export interface AutoFormProps<S extends z.ZodObject = z.ZodObject, T extends boolean = true, N extends boolean = false> extends BaseAutoFormProps<S, T, N> {
+    /** 表单的状态对象。 */
+    state?: FormProps<S, T, N>['state'];
+    /**
+     * 是否显示默认提交按钮
+     * @defaultValue true
+     */
+    submit?: boolean;
+    /** 提交按钮属性 */
+    submitButtonProps?: ButtonProps;
+    /** 数组字段添加按钮属性 */
+    addButtonProps?: ButtonProps;
+}
+export type AutoFormSubmitHandler<S extends z.ZodObject, T extends boolean = true> = (event: FormSubmitEvent<FormData<S, T>>) => void;
+export type AutoFormErrorHandler = (event: FormErrorEvent) => void;
+export interface AutoFormEmits {
+    error: [FormErrorEvent];
+}
+export type AutoFormSlots<T extends object> = {
+    header(props: AutoFormSlotProps<T>): VNode[];
+    footer(props: AutoFormSlotProps<T>): VNode[];
+    submit(props: AutoFormSlotProps<T>): VNode[];
+} & DynamicFormSlots<T>;

package/dist/runtime/types/auto-form/controls.d.ts

@@ -0,0 +1,45 @@
+import type { z } from 'zod';
+import type { ComponentProps, ComponentSlots, IsComponent, ReactiveValue } from '@movk/core';
+import type { ClassNameValue } from '../shared';
+import type { ZodAutoFormFieldMeta } from '../zod';
+import type { AutoFormFieldContext } from './fields';
+/** 幻影类型哨兵：标记 P/S 未被覆写 */
+export type _Unset = {
+    readonly __brand: 'AutoFormControlUnset';
+};
+export interface AutoFormControl<C extends IsComponent = IsComponent, _P = _Unset, _S = _Unset> {
+    component: C;
+    controlProps?: ComponentProps<C>;
+    controlSlots?: Partial<ComponentSlots<C>>;
+}
+export type AutoFormControlProps = Partial<Record<string, unknown>>;
+export type AutoFormControlSlots = Partial<Record<string, unknown>>;
+export type AutoFormControls = Record<string, AutoFormControl<IsComponent, AutoFormControlProps, AutoFormControlSlots>>;
+export interface AutoFormControlsMeta<C extends IsComponent = IsComponent> {
+    type?: string;
+    component?: C;
+    controlProps?: ReactiveValue<ComponentProps<C>, AutoFormFieldContext>;
+    controlSlots?: ReactiveValue<Partial<ComponentSlots<C>>, AutoFormFieldContext> | Record<string, unknown>;
+    error?: string;
+}
+export interface AutoFormRuntimeControlsMeta {
+    type?: string;
+    component?: IsComponent;
+    controlProps?: ReactiveValue<AutoFormControlProps, AutoFormFieldContext>;
+    controlSlots?: ReactiveValue<AutoFormControlSlots, AutoFormFieldContext> | Record<string, unknown>;
+    error?: string;
+}
+export interface AutoFormLayoutConfig<C extends IsComponent = IsComponent> {
+    component?: C;
+    props?: ReactiveValue<ComponentProps<C>, AutoFormFieldContext>;
+    class?: ReactiveValue<ClassNameValue, AutoFormFieldContext>;
+    slots?: ReactiveValue<Partial<ComponentSlots<C>>, AutoFormFieldContext>;
+    fields: Record<string, z.ZodType>;
+    fieldSlot?: ReactiveValue<keyof ComponentSlots<C> & string, AutoFormFieldContext>;
+    fieldSlots?: ReactiveValue<Partial<Record<string, keyof ComponentSlots<C> & string>>, AutoFormFieldContext>;
+}
+export type AutoFormMergeMeta = ZodAutoFormFieldMeta & AutoFormRuntimeControlsMeta & {
+    mapped?: AutoFormControl;
+    layout?: AutoFormLayoutConfig;
+    overwrite?: AutoFormRuntimeControlsMeta;
+};

package/dist/runtime/types/auto-form/fields.d.ts

@@ -0,0 +1,68 @@
+import type { CollapsibleRootProps } from 'reka-ui';
+import type { ClassNameValue } from '../shared';
+import type { GetFieldValue } from '@movk/core';
+type FieldValueType<S, P extends string> = P extends string ? (string extends P ? S[keyof S] : GetFieldValue<S, P>) : S[keyof S];
+type NonUndefinedFieldValue<S, P extends string> = Exclude<FieldValueType<S, P>, undefined>;
+type RelativePath<T> = T extends readonly any[] ? string : T extends Record<string, any> ? Extract<keyof T, string> : string;
+type _SetValueRelKey<S, P extends string> = RelativePath<NonUndefinedFieldValue<S, P>>;
+export interface AutoFormFieldContext<S = any, P extends string = string> {
+    readonly state: S;
+    readonly path: P;
+    readonly value: FieldValueType<S, P>;
+    /**
+     * @example
+     * setValue({ name: '张三', email: 'test@example.com' })  // 设置整个对象
+     * setValue('name', '张三')  // key 自动推断
+     * setValue('[0].title', '新标题')  // 数组索引路径
+     */
+    setValue: {
+        (value: FieldValueType<S, P>): void;
+        <K extends _SetValueRelKey<S, P>>(relativePath: K extends never ? string : K, value: any): void;
+        (relativePath: string, value: any): void;
+    };
+    readonly errors: unknown[];
+    readonly loading: boolean;
+    readonly open?: boolean;
+    readonly count?: number;
+}
+export interface ResolvedAutoFormFieldContext {
+    readonly state: Record<string, any>;
+    readonly path: string;
+    readonly value: any;
+    setValue: (valueOrPathOrUpdater: any, value?: any) => void;
+    readonly errors: unknown[];
+    readonly loading: boolean;
+    readonly open?: boolean;
+    readonly count?: number;
+    readonly extraProps?: Record<string, unknown>;
+}
+export interface AutoFormFieldSlots {
+    label: (props: {
+        label?: string;
+    } & AutoFormFieldContext) => unknown;
+    hint: (props: {
+        hint?: string;
+    } & AutoFormFieldContext) => unknown;
+    description: (props: {
+        description?: string;
+    } & AutoFormFieldContext) => unknown;
+    help: (props: {
+        help?: string;
+    } & AutoFormFieldContext) => unknown;
+    error: (props: {
+        error?: boolean | string;
+    } & AutoFormFieldContext) => unknown;
+    default: (props: {
+        error?: boolean | string;
+    } & AutoFormFieldContext) => unknown;
+}
+export interface AutoFormNestedCollapsible extends Pick<CollapsibleRootProps, 'defaultOpen' | 'open' | 'disabled' | 'unmountOnHide'> {
+    enabled?: boolean;
+    as?: unknown;
+    class?: unknown;
+    ui?: {
+        root?: ClassNameValue;
+        content?: ClassNameValue;
+    };
+}
+export {};

package/dist/runtime/types/auto-form/index.d.ts

@@ -0,0 +1,7 @@
+export type { AutoFormFieldContext, AutoFormFieldSlots, AutoFormNestedCollapsible, ResolvedAutoFormFieldContext } from './fields';
+export type { AutoFormControl, AutoFormControlProps, AutoFormControlSlots, AutoFormControls, AutoFormLayoutConfig, AutoFormMergeMeta } from './controls';
+export type { AutoFormField, AutoFormSlotProps, DynamicFormSlots } from './slots';
+export type { TypedZodFactory } from './zod-factory';
+export type { BaseAutoFormProps } from './base';
+export type { AutoFormEmits, AutoFormProps, AutoFormSlots, AutoFormErrorHandler, AutoFormSubmitHandler } from './component';
+export type { SearchFormEmits, SearchFormProps, SearchFormSlots, SearchFormAction, SearchFormSlotProps } from './search-form';

package/dist/runtime/types/auto-form/search-form.d.ts

@@ -0,0 +1,84 @@
+import type { ButtonProps, FormError, FormErrorEvent, IconProps, InferInput } from '@nuxt/ui';
+import type { z } from 'zod';
+import type { Suggest } from '@movk/core';
+import type { BaseAutoFormProps } from './base';
+import type { DynamicFormSlots } from './slots';
+import type { VNode } from 'vue';
+export interface SearchFormSlotProps<S extends z.ZodObject> {
+    expanded: boolean;
+    loading: boolean;
+    state: Partial<InferInput<S>>;
+    errors: FormError[];
+    toggle: () => void;
+    search: () => void;
+    reset: () => void;
+    clear: () => void;
+}
+export interface SearchFormAction extends /** @vue-ignore */ Omit<ButtonProps, 'onClick'> {
+    key: Suggest<'search' | 'reset'>;
+    label?: string;
+    visible?: boolean | ((ctx: SearchFormSlotProps<z.ZodObject>) => boolean);
+    onClick?: (ctx: SearchFormSlotProps<z.ZodObject>) => void;
+}
+export interface SearchFormProps<S extends z.ZodObject> extends BaseAutoFormProps<S> {
+    /**
+     * 网格列数
+     * @defaultValue 3
+     */
+    cols?: number | {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+    /**
+     * 可见行数（折叠时显示的行数）
+     * @defaultValue 1
+     */
+    visibleRows?: number;
+    /**
+     * 动作按钮配置；不传时使用默认 [search, reset]；传 [] 则关闭所有内置按钮
+     * @defaultValue [{ key: 'search', ... }, { key: 'reset', ... }]
+     */
+    actions?: SearchFormAction[];
+    /** 搜索按钮加载状态（作用于 type==='submit' 或 key==='search' 的按钮） */
+    loading?: boolean;
+    /** 收起按钮属性 */
+    collapseButtonProps?: ButtonProps;
+    /**
+     * 展开/收起按钮图标
+     * @IconifyIcon
+     * @defaultValue 'i-lucide-chevron-down'
+     */
+    icon?: IconProps['name'];
+    /**
+     * 展开按钮文本
+     * @defaultValue '展开'
+     */
+    expandText?: string;
+    /**
+     * 收起按钮文本
+     * @defaultValue '收起'
+     */
+    collapseText?: string;
+    /** 受控展开状态；优先级高于 defaultExpanded */
+    expanded?: boolean;
+    /**
+     * 默认展开状态
+     * @defaultValue false
+     */
+    defaultExpanded?: boolean;
+}
+export interface SearchFormEmits {
+    'reset': [];
+    'clear': [];
+    'expand': [expanded: boolean];
+    'update:expanded': [expanded: boolean];
+    'error': [event: FormErrorEvent];
+}
+export type SearchFormSlots<S extends z.ZodObject> = {
+    header(props: SearchFormSlotProps<S>): VNode[];
+    footer(props: SearchFormSlotProps<S>): VNode[];
+    actions(props: SearchFormSlotProps<S>): VNode[];
+    extraActions(props: SearchFormSlotProps<S>): VNode[];
+} & DynamicFormSlots<Partial<InferInput<S>>>;

package/dist/runtime/types/auto-form/slots.d.ts

@@ -0,0 +1,85 @@
+import type { z } from 'zod';
+import type { FormError } from '@nuxt/ui';
+import type { ArrayFieldKeys, NonObjectFieldKeys, ObjectFieldKeys } from '@movk/core';
+import type { AutoFormFieldContext, AutoFormFieldSlots } from './fields';
+import type { AutoFormMergeMeta } from './controls';
+import type { VNode } from 'vue';
+export interface AutoFormField {
+    path: string;
+    schema: z.ZodType;
+    meta: AutoFormMergeMeta;
+    decorators: {
+        isOptional?: boolean;
+        isReadonly?: boolean;
+        defaultValue?: unknown;
+        description?: string;
+    };
+    children?: AutoFormField[];
+    arrayElement?: AutoFormField;
+}
+export interface AutoFormSlotProps<T extends object> {
+    errors: FormError[];
+    loading: boolean;
+    fields: AutoFormField[];
+    state: T;
+}
+/** 插槽附加 props 查找表 */
+type SlotExtraPropsMap = {
+    label: {
+        label?: string;
+    };
+    hint: {
+        hint?: string;
+    };
+    description: {
+        description?: string;
+    };
+    help: {
+        help?: string;
+    };
+    error: {
+        error?: boolean | string;
+    };
+    default: {
+        error?: boolean | string;
+    };
+};
+type _FormGenericSlots<T> = {
+    [K in keyof AutoFormFieldSlots as `field-${K}`]: (props: SlotExtraPropsMap[K] & AutoFormFieldContext<T>) => VNode[];
+};
+type _FieldPath<T> = string & (NonObjectFieldKeys<T> | ObjectFieldKeys<T>);
+type _NestedPath<T> = string & (ObjectFieldKeys<T> | ArrayFieldKeys<T>);
+type _SlotEntry = {
+    key: PropertyKey;
+    props: unknown;
+};
+type _EntryToSlots<E extends _SlotEntry> = {
+    [Entry in E as Entry['key']]: (props: Entry['props']) => VNode[];
+};
+type _FormKeyedSlotEntry<T> = {
+    [K in keyof AutoFormFieldSlots]: {
+        [P in _FieldPath<T>]: {
+            key: `field-${K}:${P}`;
+            props: SlotExtraPropsMap[K] & AutoFormFieldContext<T, P>;
+        };
+    }[_FieldPath<T>];
+}[keyof AutoFormFieldSlots];
+type _NestedSlotName = 'content' | 'before' | 'after';
+type _FormNestedSlotEntry<T> = {
+    [P in _NestedPath<T>]: {
+        key: `field-${_NestedSlotName}:${P}`;
+        props: AutoFormFieldContext<T, P>;
+    };
+}[_NestedPath<T>];
+type _FormKeyedSlots<T> = _EntryToSlots<_FormKeyedSlotEntry<T>>;
+type _FormNestedSlots<T> = _EntryToSlots<_FormNestedSlotEntry<T>>;
+/**
+ * 动态表单插槽类型
+ *
+ * 插槽命名：
+ * - 通用：`field-{slotType}`
+ * - 字段：`field-{slotType}:{fieldKey}` — 精确推导字段类型
+ * - 嵌套：`field-{content|before|after}:{objectKey|arrayKey}`
+ */
+export type DynamicFormSlots<T> = _FormGenericSlots<T> & _FormKeyedSlots<T> & _FormNestedSlots<T>;
+export {};

package/dist/runtime/types/auto-form/zod-factory.d.ts

@@ -0,0 +1,127 @@
+import type { z } from 'zod';
+import type { DateRange } from 'reka-ui';
+import type { CalendarDate, DateValue, Time } from '@internationalized/date';
+import type { ComponentProps, ComponentSlots, IsAny, IsComponent, KnownKeys, OmitByKey, Prettify, ReactiveValue, UnionToIntersection, WidenLiteral } from '@movk/core';
+import type { AutoFormFieldContext } from './fields';
+import type { AutoFormControl, AutoFormControls, AutoFormControlsMeta, _Unset, AutoFormLayoutConfig } from './controls';
+import type { AUTOFORM_META } from '../../domains/auto-form/constants';
+interface LayoutFieldMarker<Fields extends Record<string, z.ZodType>> extends z.ZodType<AutoFormLayoutConfig, any, any> {
+    __brand: typeof AUTOFORM_META.LAYOUT_KEY;
+    fields: Fields;
+}
+type LayoutRestShape<S extends Record<string, any>> = {
+    [P in keyof S as S[P] extends LayoutFieldMarker<any> ? never : P]: S[P];
+};
+type LayoutFieldShape<S extends Record<string, any>> = UnionToIntersection<{
+    [P in keyof S]: S[P] extends LayoutFieldMarker<infer Fields> ? ExtractLayoutShape<Fields> : {};
+}[keyof S]>;
+type _HasLayoutMarker<S> = {
+    [P in keyof S]: S[P] extends LayoutFieldMarker<any> ? true : never;
+}[keyof S] extends never ? false : true;
+type ExtractLayoutShape<S extends Record<string, any>> = _HasLayoutMarker<S> extends true ? LayoutRestShape<S> & LayoutFieldShape<S> : S;
+type StrictComponentProps<C extends IsComponent> = {
+    [K in keyof ComponentProps<C> as {} extends Record<K, unknown> ? never : K]: ComponentProps<C>[K];
+};
+type StrictComponentSlots<C extends IsComponent> = IsAny<ComponentSlots<C>> extends true ? {} : ComponentSlots<C>;
+type ControlKey<TControls extends AutoFormControls> = Extract<KnownKeys<TControls>, string>;
+type ControlEntryByKey<TControls extends AutoFormControls, K extends string> = K extends keyof TControls ? TControls[K] : never;
+type _WidenForFactory<T> = {
+    [K in keyof T]+?: WidenLiteral<T[K]>;
+};
+type _IsUnsetLike<P> = [P] extends [_Unset] ? true : IsAny<P> extends true ? true : [unknown] extends [P] ? true : [keyof P] extends [never] ? true : false;
+type ResolveControlProps<C extends IsComponent, P> = _IsUnsetLike<P> extends true ? StrictComponentProps<C> : Prettify<_WidenForFactory<P> & {}>;
+type ExtractControlProps<T> = T extends AutoFormControl<infer C, infer P, any> ? ResolveControlProps<C, P> : T extends {
+    component: infer C extends IsComponent;
+} ? StrictComponentProps<C> : {};
+type ResolveControlSlots<C extends IsComponent, S> = _IsUnsetLike<S> extends true ? StrictComponentSlots<C> : S;
+type ExtractControlSlots<T> = T extends AutoFormControl<infer C, any, infer S> ? ResolveControlSlots<C, S> : T extends {
+    component: infer C extends IsComponent;
+} ? StrictComponentSlots<C> : {};
+type FallbackToRecordIfEmpty<T> = [keyof T] extends [never] ? Record<string, unknown> : Prettify<T & {}>;
+type ControlPropsByKey<TControls extends AutoFormControls, K extends ControlKey<TControls>> = FallbackToRecordIfEmpty<ExtractControlProps<ControlEntryByKey<TControls, K>>>;
+type ControlSlotsByKey<TControls extends AutoFormControls, K extends ControlKey<TControls>> = Partial<ExtractControlSlots<ControlEntryByKey<TControls, K>>>;
+type MetaPropsFor<TControls extends AutoFormControls, K extends ControlKey<TControls>> = {
+    controlProps?: ReactiveValue<ControlPropsByKey<TControls, K>, AutoFormFieldContext>;
+    controlSlots?: ReactiveValue<ControlSlotsByKey<TControls, K>, AutoFormFieldContext> | Record<string, unknown>;
+    error?: string;
+};
+type MetaByControlKey<TControls extends AutoFormControls, K extends ControlKey<TControls>> = {
+    type: K;
+    component?: never;
+} & MetaPropsFor<TControls, K>;
+type MetaByComponent<C extends IsComponent> = {
+    component: C;
+    type?: never;
+} & OmitByKey<AutoFormControlsMeta<C>, 'component' | 'type'>;
+type MetaByDefaultIfExists<TControls extends AutoFormControls, TDefaultKey extends string> = TDefaultKey extends ControlKey<TControls> ? {
+    component?: never;
+    type?: never;
+} & MetaPropsFor<TControls, TDefaultKey> : never;
+type AutoFormFactoryMethod<TControls extends AutoFormControls, TResult, TDefaultKey extends string, TExtraArgs extends unknown[] = []> = _FactoryMetaOverloads<TControls, TResult, TDefaultKey, TExtraArgs> & {
+    (...args: [...TExtraArgs, string?]): TResult;
+};
+type _FactoryMetaOverloads<TControls extends AutoFormControls, TResult, TDefaultKey extends string, TExtraArgs extends unknown[] = []> = {
+    <K extends ControlKey<TControls>>(...args: [...TExtraArgs, MetaByControlKey<TControls, K>]): TResult;
+    (...args: [...TExtraArgs, MetaByDefaultIfExists<TControls, TDefaultKey>]): TResult;
+    <C extends IsComponent>(...args: [...TExtraArgs, MetaByComponent<C>]): TResult;
+};
+type EnumValues = readonly string[] | z.core.util.EnumLike;
+type EnumFactoryResult<T extends EnumValues> = T extends readonly [] ? z.ZodString : T extends readonly [string, ...string[]] ? z.ZodEnum<z.core.util.ToEnum<T[number]>> : T extends readonly string[] ? z.ZodEnum<z.core.util.ToEnum<T[number]>> : T extends z.core.util.EnumLike ? z.ZodEnum<T> : z.ZodString;
+type EnumFactory<TControls extends AutoFormControls> = {
+    <const T extends EnumValues, K extends ControlKey<TControls>>(values: T, overwrite?: MetaByControlKey<TControls, K>): EnumFactoryResult<T>;
+    <const T extends EnumValues>(values: T, overwrite: MetaByDefaultIfExists<TControls, 'enum'>): EnumFactoryResult<T>;
+    <const T extends EnumValues, C extends IsComponent>(values: T, overwrite: MetaByComponent<C>): EnumFactoryResult<T>;
+};
+type CalendarDateFactory<TControls extends AutoFormControls> = {
+    <T extends DateValue | DateRange | DateValue[] = CalendarDate, K extends ControlKey<TControls> = ControlKey<TControls>>(meta?: MetaByControlKey<TControls, K>): z.ZodType<T>;
+    <T extends DateValue | DateRange | DateValue[] = CalendarDate>(meta: MetaByDefaultIfExists<TControls, 'calendarDate'>): z.ZodType<T>;
+    <C extends IsComponent, T extends DateValue | DateRange | DateValue[] = CalendarDate>(meta: MetaByComponent<C>): z.ZodType<T>;
+};
+type ArrayFactory<TControls extends AutoFormControls> = {
+    <T extends z.ZodType, K extends ControlKey<TControls>>(schema: T, overwrite?: MetaByControlKey<TControls, K>): z.ZodArray<T>;
+    <T extends z.ZodType>(schema: T, overwrite: MetaByDefaultIfExists<TControls, 'array'>): z.ZodArray<T>;
+    <T extends z.ZodType, C extends IsComponent>(schema: T, overwrite: MetaByComponent<C>): z.ZodArray<T>;
+};
+type TupleFactory<TControls extends AutoFormControls> = {
+    <T extends readonly [z.ZodType, ...z.ZodType[]], K extends ControlKey<TControls>>(schemas: T, overwrite?: MetaByControlKey<TControls, K>): z.ZodTuple<T>;
+    <T extends readonly [z.ZodType, ...z.ZodType[]]>(schemas: T, overwrite: MetaByDefaultIfExists<TControls, 'tuple'>): z.ZodTuple<T>;
+    <T extends readonly [z.ZodType, ...z.ZodType[]], C extends IsComponent>(schemas: T, overwrite: MetaByComponent<C>): z.ZodTuple<T>;
+};
+type ObjectFactoryResult<S extends Record<string, z.ZodType>, Mode extends z.core.$strip | z.core.$loose | z.core.$strict> = z.ZodObject<ExtractLayoutShape<S>, Mode>;
+/** 对象工厂重载 */
+type ObjectFactoryOverloads<TControls extends AutoFormControls, Mode extends z.core.$strip | z.core.$loose | z.core.$strict, TDefaultKey extends string, ShapeConstraint = {}> = {
+    <S extends Record<string, z.ZodType>, K extends ControlKey<TControls>>(shape: S & ShapeConstraint, meta?: MetaByControlKey<TControls, K>): ObjectFactoryResult<S, Mode>;
+    <S extends Record<string, z.ZodType>>(shape: S & ShapeConstraint, meta: MetaByDefaultIfExists<TControls, TDefaultKey>): ObjectFactoryResult<S, Mode>;
+    <S extends Record<string, z.ZodType>, C extends IsComponent>(shape: S & ShapeConstraint, meta: MetaByComponent<C>): ObjectFactoryResult<S, Mode>;
+};
+export interface TypedZodFactory<TControls extends AutoFormControls> {
+    string: AutoFormFactoryMethod<TControls, z.ZodString, 'string'>;
+    number: AutoFormFactoryMethod<TControls, z.ZodNumber, 'number'>;
+    boolean: AutoFormFactoryMethod<TControls, z.ZodBoolean, 'boolean'>;
+    file: AutoFormFactoryMethod<TControls, z.ZodType<File>, 'file'>;
+    email: AutoFormFactoryMethod<TControls, z.ZodString, 'string'>;
+    url: AutoFormFactoryMethod<TControls, z.ZodString, 'string'>;
+    uuid: AutoFormFactoryMethod<TControls, z.ZodString, 'string'>;
+    enum: EnumFactory<TControls>;
+    calendarDate: CalendarDateFactory<TControls>;
+    inputDate: AutoFormFactoryMethod<TControls, z.ZodType<CalendarDate>, 'inputDate'>;
+    inputTime: AutoFormFactoryMethod<TControls, z.ZodType<Time>, 'inputTime'>;
+    isoDatetime: AutoFormFactoryMethod<TControls, z.ZodType<string>, 'string'>;
+    isoDate: AutoFormFactoryMethod<TControls, z.ZodType<string>, 'string'>;
+    isoTime: AutoFormFactoryMethod<TControls, z.ZodType<string>, 'string'>;
+    array: ArrayFactory<TControls>;
+    tuple: TupleFactory<TControls>;
+    layout: <C extends IsComponent = IsComponent, Fields extends Record<string, z.ZodType> = Record<string, z.ZodType>>(config: Omit<AutoFormLayoutConfig<C>, 'fields'> & {
+        fields: Fields;
+    }) => LayoutFieldMarker<Fields>;
+    object: {
+        <T extends object>(): ObjectFactoryOverloads<TControls, z.core.$strip, 'object', Partial<Record<Extract<keyof T, string>, z.ZodType>>>;
+    } & ObjectFactoryOverloads<TControls, z.core.$strip, 'object'>;
+    looseObject: {
+        <T extends object>(): ObjectFactoryOverloads<TControls, z.core.$loose, 'looseObject', Partial<Record<Extract<keyof T, string>, z.ZodType>>>;
+    } & ObjectFactoryOverloads<TControls, z.core.$loose, 'looseObject'>;
+    strictObject: {
+        <T extends object>(): ObjectFactoryOverloads<TControls, z.core.$strict, 'strictObject', Partial<Record<Extract<keyof T, string>, z.ZodType>>>;
+    } & ObjectFactoryOverloads<TControls, z.core.$strict, 'strictObject'>;
+}
+export {};

package/dist/runtime/types/components/color-chooser.d.ts

@@ -0,0 +1,109 @@
+import type { VNode } from 'vue';
+import type { ButtonProps, ColorPickerProps, IconProps, PopoverProps } from '@nuxt/ui';
+import type { OmitByKey } from '@movk/core';
+import type { ClassNameValue } from '../shared';
+type PopoverMode = 'click' | 'hover';
+export type ColorFormat = NonNullable<ColorPickerProps['format']>;
+export type ColorChooserTrigger = 'button' | 'chip' | 'input';
+export interface ColorChooserProps<M extends PopoverMode = PopoverMode> extends /** @vue-ignore */ OmitByKey<PopoverProps<M>, 'open' | 'defaultOpen' | 'ui'> {
+    id?: string;
+    name?: string;
+    /**
+     * 当前激活的颜色格式。
+     * @defaultValue 'hex'
+     */
+    format?: ColorFormat;
+    /**
+     * 启用的颜色格式 tab 列表，长度 >= 2 时在 popover 顶部渲染切换器。
+     * 仅一项时不渲染 tab，等价于 `format`。
+     * @defaultValue ['hex']
+     */
+    formats?: ColorFormat[];
+    /**
+     * 预设色板。
+     * 一维数组渲染为单行，二维数组渲染为多行分组。
+     */
+    swatches?: string[] | string[][];
+    /**
+     * 点击预设色后是否自动关闭弹层。
+     * @defaultValue true
+     */
+    closeOnSwatch?: boolean;
+    /** 是否在底部 actions 区显示清除按钮。 */
+    clearable?: boolean;
+    /** actions 区显示复制按钮（基于 navigator.clipboard）。 */
+    copyable?: boolean;
+    /**
+     * 触发器形态。
+     * - `button`：色点 + 色值 / label 的常规按钮（默认）
+     * - `chip`：仅一个圆形色点
+     * - `input`：色点 leading + 可输入色值文本框
+     * @defaultValue 'button'
+     */
+    trigger?: ColorChooserTrigger;
+    /** `trigger='button'` 时按钮上的文本，未传则显示当前色值。 */
+    label?: string;
+    /**
+     * 未选中颜色时的占位文案。
+     * @defaultValue '选择颜色'
+     */
+    placeholder?: string;
+    /**
+     * 触发器尺寸，同时驱动主题 size variant。
+     * @defaultValue 'md'
+     */
+    size?: ButtonProps['size'];
+    /** 触发按钮的颜色（trigger=button|chip 生效）。 */
+    color?: ButtonProps['color'];
+    /**
+     * 触发按钮的视觉变体（trigger=button|chip 生效）。
+     * @defaultValue 'subtle'
+     */
+    variant?: ButtonProps['variant'];
+    /** 是否禁用。禁用时弹层不会打开、所有交互失效。 */
+    disabled?: boolean;
+    /** Highlight the ring color like a focus state. */
+    highlight?: boolean;
+    /**
+     * 未选中颜色时占位的图标。
+     * @IconifyIcon
+     * @defaultValue 'i-lucide-palette'
+     */
+    icon?: IconProps['name'];
+    /**
+     * 透传给 `UColorPicker` 的属性。
+     * `modelValue`、`format`、`disabled` 由组件内部托管。
+     */
+    colorPickerProps?: Omit<ColorPickerProps, 'modelValue' | 'format' | 'disabled'>;
+    ui?: Record<string, ClassNameValue>;
+}
+export interface ColorChooserEmits {
+    'update:modelValue': [value: string | undefined];
+    'update:open': [open: boolean];
+    'change': [value: string | undefined];
+    'clear': [];
+    'copy': [value: string];
+    'format-change': [format: ColorFormat];
+}
+export interface ColorChooserSlots {
+    default?(props: {
+        open: boolean;
+        value: string | undefined;
+    }): VNode[];
+    leading?(props: {
+        value: string | undefined;
+    }): VNode[];
+    trailing?(props: {
+        value: string | undefined;
+    }): VNode[];
+    swatches?(props: {
+        swatches: string[][];
+        select: (color: string) => void;
+    }): VNode[];
+    actions?(props: {
+        value: string | undefined;
+        copy: () => void;
+        clear: () => void;
+    }): VNode[];
+}
+export {};

package/dist/runtime/types/components/date-picker.d.ts

@@ -0,0 +1,41 @@
+import type { ButtonProps, ButtonSlots, CalendarEmits, CalendarProps, CalendarSlots, PopoverEmits, PopoverProps, PopoverSlots } from '@nuxt/ui';
+import type { OmitByKey } from '@movk/core';
+import type { DateValue } from '@internationalized/date';
+import type { DateFormatter, DateFormatterOptions, ValueFormat } from '../../composables/useDateFormatter';
+import type { ClassNameValue } from '../shared';
+export type { ValueFormat } from '../../composables/useDateFormatter';
+export type LabelFormat = 'iso' | 'formatted' | 'date' | 'timestamp' | 'unix';
+export type DatePickerLabelFormatter<R extends boolean, M extends boolean> = (formatter: DateFormatter, modelValue: CalendarProps<R, M>['modelValue']) => string;
+type PopoverMode = 'click' | 'hover';
+type FormattedSingle<V extends ValueFormat> = V extends 'date-value' ? DateValue : V extends 'iso' ? string : V extends 'timestamp' ? number : V extends 'unix' ? number : V extends 'date' ? Date : never;
+export type FormattedValue<R extends boolean, M extends boolean, V extends ValueFormat> = M extends true ? FormattedSingle<V>[] : R extends true ? {
+    start: FormattedSingle<V> | undefined;
+    end: FormattedSingle<V> | undefined;
+} | undefined : FormattedSingle<V> | undefined;
+export interface DatePickerPreset<R extends boolean, M extends boolean> {
+    label: string;
+    value: CalendarProps<R, M>['modelValue'] | ((formatter: DateFormatter) => CalendarProps<R, M>['modelValue']);
+}
+export interface DatePickerProps<R extends boolean, M extends boolean, P extends PopoverMode = PopoverMode, V extends ValueFormat = 'date-value'> extends DateFormatterOptions, 
+/** @vue-ignore */ OmitByKey<CalendarProps<R, M>, 'modelValue' | 'placeholder' | 'ui'> {
+    id?: string;
+    name?: string;
+    /** @defaultValue '选择日期' */
+    placeholder?: string;
+    buttonProps?: ButtonProps;
+    popoverProps?: PopoverProps<P>;
+    labelFormat?: LabelFormat | DatePickerLabelFormatter<R, M>;
+    /**
+     * v-model 投影输出格式
+     * @defaultValue 'date-value'
+     */
+    valueFormat?: V;
+    clearable?: boolean;
+    /** 快捷预设 */
+    presets?: DatePickerPreset<R, M>[] | 'default';
+    ui?: Record<string, ClassNameValue>;
+}
+export type DatePickerEmits<R extends boolean, M extends boolean, V extends ValueFormat = 'date-value'> = PopoverEmits & Omit<CalendarEmits<R, M>, 'update:modelValue'> & {
+    'update:modelValue': [value: FormattedValue<R, M, V>];
+};
+export type DatePickerSlots<P extends PopoverMode = PopoverMode> = OmitByKey<PopoverSlots<P>, 'anchor'> & CalendarSlots & OmitByKey<ButtonSlots, 'default'>;