@movk/nuxt 1.1.2 → 1.3.0

package/dist/runtime/domains/auto-form/components/Nested.vue

@@ -0,0 +1,47 @@
+<script setup>
+import { UCollapsible } from "#components";
+import { computed } from "vue";
+import { useAutoFormInjector } from "../provider";
+import { isLeafField } from "../fields";
+import { VNodeRender } from "../reactive";
+import AutoFormRendererField from "./Field.vue";
+import AutoFormRendererChildren from "./Children.vue";
+const props = defineProps({
+  schema: { type: null, required: true },
+  field: { type: Object, required: true },
+  extraProps: { type: Object, required: false }
+});
+const { createSlotResolver, createSlotProps, createCollapsibleEnhancer, resolveFieldProp } = useAutoFormInjector();
+const visibleFields = computed(() => {
+  if (isLeafField(props.field) || !props.field.children?.length) {
+    return [];
+  }
+  return props.field.children.filter(
+    (f) => f && (f.meta?.if === void 0 || resolveFieldProp(f, "if") === true)
+  );
+});
+const slotResolver = computed(() => createSlotResolver(props.field, props.extraProps));
+const { collapsibleConfig, shouldShowCollapsible, isHidden, enhancedField } = createCollapsibleEnhancer(props.field, props.extraProps);
+const slotProps = computed(() => createSlotProps(props.field, props.extraProps));
+</script>
+
+<template>
+  <UCollapsible v-if="shouldShowCollapsible && visibleFields.length" v-show="!isHidden" v-bind="collapsibleConfig || {}">
+    <template #default="{ open }">
+      <AutoFormRendererField :field="enhancedField" :schema="props.schema" :extra-props="{ ...props.extraProps, open }" />
+    </template>
+    <template #content>
+      <VNodeRender v-if="slotResolver.hasSlot('before')" :node="slotResolver.renderSlot('before', slotProps)" />
+      <VNodeRender v-if="slotResolver.hasSlot('content')" :node="slotResolver.renderSlot('content', slotProps)" />
+      <AutoFormRendererChildren v-else :fields="visibleFields" :schema="props.schema" :extra-props="props.extraProps" />
+      <VNodeRender v-if="slotResolver.hasSlot('after')" :node="slotResolver.renderSlot('after', slotProps)" />
+    </template>
+  </UCollapsible>
+
+  <AutoFormRendererChildren
+    v-else-if="visibleFields.length"
+    :fields="visibleFields"
+    :schema="props.schema"
+    :extra-props="props.extraProps"
+  />
+</template>

package/dist/runtime/domains/auto-form/components/Nested.vue.d.ts

@@ -0,0 +1,11 @@
+import type { z } from 'zod';
+import type { AutoFormField } from '../../../types';
+import type { AnyObject } from '@movk/core';
+interface AutoFormRendererNestedProps {
+    schema: z.ZodObject;
+    field: AutoFormField;
+    extraProps?: AnyObject;
+}
+declare const __VLS_export: import("vue").DefineComponent<AutoFormRendererNestedProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AutoFormRendererNestedProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/{constants/auto-form.d.ts → domains/auto-form/constants.d.ts}

@@ -14,5 +14,3 @@ export declare const AUTOFORM_PATTERNS: {
     /** 事件属性检测正则，匹配 onClick、onChange 等 Vue/React 事件命名模式 */
     readonly EVENT_PROP: RegExp;
 };
-/** zod 克隆方法 */
-export declare const CLONE_METHODS: readonly ["meta", "max", "min", "length", "regex", "startsWith", "endsWith", "includes", "uppercase", "lowercase", "optional", "nullable", "nullish", "describe", "refine", "superRefine", "check", "transform", "default", "mime", "readonly", "exclude", "extract"];

package/dist/runtime/{constants/auto-form.js → domains/auto-form/constants.js}

@@ -14,28 +14,3 @@ export const AUTOFORM_PATTERNS = {
   /** 事件属性检测正则，匹配 onClick、onChange 等 Vue/React 事件命名模式 */
   EVENT_PROP: /^on[A-Z]/
 };
-export const CLONE_METHODS = [
-  "meta",
-  "max",
-  "min",
-  "length",
-  "regex",
-  "startsWith",
-  "endsWith",
-  "includes",
-  "uppercase",
-  "lowercase",
-  "optional",
-  "nullable",
-  "nullish",
-  "describe",
-  "refine",
-  "superRefine",
-  "check",
-  "transform",
-  "default",
-  "mime",
-  "readonly",
-  "exclude",
-  "extract"
-];

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

@@ -0,0 +1,41 @@
+import type { IsComponent } from '@movk/core';
+import type { AutoFormControl, _Unset } from '../../types/auto-form/controls';
+import type { InputProps, InputSlots, TextareaProps, TextareaSlots } from '@nuxt/ui';
+import { UInput, UTextarea } from '#components';
+export declare function defineControl<C extends IsComponent, P = _Unset, S = _Unset>(e: AutoFormControl<C, P, S>): AutoFormControl<C, P, S>;
+declare const DEFAULT_CONTROL_COMPONENTS: {
+    readonly string: any;
+    readonly number: any;
+    readonly boolean: any;
+    readonly enum: any;
+    readonly file: any;
+    readonly calendarDate: any;
+    readonly inputDate: any;
+    readonly inputTime: any;
+    readonly withClear: any;
+    readonly withPasswordToggle: any;
+    readonly withCopy: any;
+    readonly withCharacterLimit: any;
+    readonly withFloatingLabel: any;
+    readonly asPhoneNumberInput: any;
+    readonly textarea: any;
+    readonly switch: any;
+    readonly slider: any;
+    readonly selectMenu: any;
+    readonly inputMenu: any;
+    readonly checkboxGroup: any;
+    readonly radioGroup: any;
+    readonly inputTags: any;
+    readonly pinInput: any;
+    readonly listbox: any;
+    readonly starRating: any;
+    readonly colorChooser: any;
+    readonly slideVerify: any;
+    readonly pillGroup: any;
+};
+type DefaultControlComponents = typeof DEFAULT_CONTROL_COMPONENTS;
+type DefaultControlMap = {
+    readonly [K in keyof DefaultControlComponents]: K extends 'string' ? AutoFormControl<typeof UInput, InputProps, InputSlots> : K extends 'textarea' ? AutoFormControl<typeof UTextarea, TextareaProps, TextareaSlots> : AutoFormControl<DefaultControlComponents[K]>;
+};
+export declare const DEFAULT_CONTROLS: DefaultControlMap;
+export {};

package/dist/runtime/domains/auto-form/controls.js

@@ -0,0 +1,73 @@
+import WithClear from "../../components/input/WithClear.vue";
+import WithPasswordToggle from "../../components/input/WithPasswordToggle.vue";
+import WithCopy from "../../components/input/WithCopy.vue";
+import WithCharacterLimit from "../../components/input/WithCharacterLimit.vue";
+import AsPhoneNumberInput from "../../components/input/AsPhoneNumberInput.vue";
+import WithFloatingLabel from "../../components/input/WithFloatingLabel.vue";
+import DatePicker from "../../components/DatePicker.vue";
+import ColorChooser from "../../components/ColorChooser.vue";
+import StarRating from "../../components/StarRating.vue";
+import SlideVerify from "../../components/SlideVerify.vue";
+import PillGroup from "../../components/PillGroup.vue";
+import {
+  UInput,
+  UInputNumber,
+  UCheckbox,
+  USwitch,
+  UTextarea,
+  USlider,
+  UPinInput,
+  UInputTags,
+  UFileUpload,
+  USelect,
+  USelectMenu,
+  UInputMenu,
+  UCheckboxGroup,
+  URadioGroup,
+  UInputDate,
+  UInputTime,
+  UListbox
+} from "#components";
+const DEFAULT_CONTROL_PROPS = { class: "w-full" };
+export function defineControl(e) {
+  return e;
+}
+function createControlMap(components, defaultProps = DEFAULT_CONTROL_PROPS) {
+  return Object.fromEntries(
+    Object.entries(components).map(([key, component]) => [
+      key,
+      { component, controlProps: defaultProps }
+    ])
+  );
+}
+const DEFAULT_CONTROL_COMPONENTS = {
+  string: UInput,
+  number: UInputNumber,
+  boolean: UCheckbox,
+  enum: USelect,
+  file: UFileUpload,
+  calendarDate: DatePicker,
+  inputDate: UInputDate,
+  inputTime: UInputTime,
+  withClear: WithClear,
+  withPasswordToggle: WithPasswordToggle,
+  withCopy: WithCopy,
+  withCharacterLimit: WithCharacterLimit,
+  withFloatingLabel: WithFloatingLabel,
+  asPhoneNumberInput: AsPhoneNumberInput,
+  textarea: UTextarea,
+  switch: USwitch,
+  slider: USlider,
+  selectMenu: USelectMenu,
+  inputMenu: UInputMenu,
+  checkboxGroup: UCheckboxGroup,
+  radioGroup: URadioGroup,
+  inputTags: UInputTags,
+  pinInput: UPinInput,
+  listbox: UListbox,
+  starRating: StarRating,
+  colorChooser: ColorChooser,
+  slideVerify: SlideVerify,
+  pillGroup: PillGroup
+};
+export const DEFAULT_CONTROLS = createControlMap(DEFAULT_CONTROL_COMPONENTS);

package/dist/runtime/{utils/field-utils.d.ts → domains/auto-form/fields.d.ts}

@@ -1,8 +1,8 @@
 import type { VNode } from 'vue';
-import type { AutoFormField } from '../types/auto-form.js';
-/**
- * 字段分类
- */
+import type { AutoFormField } from '../../types/auto-form';
+/** 沿字段树回填带 defaultValue 的叶子节点，已存在值的路径不覆盖 */
+export declare function applyFieldDefaults(fields: AutoFormField[], target: Record<string, any>): void;
+/** 将字段列表分类为叶子/嵌套/数组/布局四组 */
 export declare function classifyFields(fields: AutoFormField[]): {
     leafFields: AutoFormField[];
     nestedFields: AutoFormField[];
@@ -10,25 +10,11 @@ export declare function classifyFields(fields: AutoFormField[]): {
     layoutFields: AutoFormField[];
     hasComplexFields: boolean;
 };
-/**
- * 优化的字段类型检测 - 基于 meta.type 判断
- * @param field - 自动表单字段
- * @returns 是否为叶子字段（非 object 和 array）
- */
 export declare function isLeafField(field: AutoFormField): boolean;
-/**
- * 获取字段类型
- * @param field - 自动表单字段
- * @returns 字段类型
- */
 export declare function getFieldType(field: AutoFormField): 'leaf' | 'nested';
-/**
- * 收集字段默认值
- */
+/** 递归收集字段的默认值，object 类型返回嵌套结构，叶子类型直接返回值 */
 export declare function collectFieldDefaults(field: AutoFormField): {} | null | undefined;
-/**
- * 从 SelectMenuItem 数组中提取枚举值
- */
+/** 从 items 选项中提取枚举值，支持对象格式（取 valueKey/value/label）和原始值 */
 export declare function extractEnumValuesFromItems(items: any, valueKey?: string): string[];
-/** 创建提示插槽工厂 */
+/** 创建数组项的 hint 插槽渲染函数，根据层级和字段类型组合删除按钮与折叠图标 */
 export declare function createHintSlotFactory(removeCallback: (count?: number) => void): (field: AutoFormField, path: string, open?: boolean, count?: number) => VNode | undefined;

package/dist/runtime/{utils/field-utils.js → domains/auto-form/fields.js}

@@ -1,7 +1,23 @@
 import { UButton, UIcon } from "#components";
 import { h } from "vue";
-import { setPath } from "@movk/core";
-import { AUTOFORM_META } from "../constants/auto-form.js";
+import { getPath, setPath } from "@movk/core";
+import { AUTOFORM_META } from "./constants.js";
+export function applyFieldDefaults(fields, target) {
+  if (!fields.length) return;
+  const updates = [];
+  function collect(items) {
+    for (const field of items) {
+      if (field?.decorators?.defaultValue !== void 0 && getPath(target, field.path) === void 0) {
+        updates.push({ path: field.path, value: field.decorators.defaultValue });
+      }
+      if (field?.children && Array.isArray(field.children) && field.children.length > 0) {
+        collect(field.children);
+      }
+    }
+  }
+  collect(fields);
+  for (const { path, value } of updates) setPath(target, path, value);
+}
 export function classifyFields(fields) {
   const leafFields = [];
   const nestedFields = [];
@@ -95,7 +111,6 @@ export function createHintSlotFactory(removeCallback) {
       color: "error",
       variant: "ghost",
       size: "xs",
-      square: true,
       onClick: (event) => {
         event?.stopPropagation();
         removeCallback(count);
@@ -104,7 +119,7 @@ export function createHintSlotFactory(removeCallback) {
     if (!isObject) {
       return deleteButton;
     }
-    return h("div", { class: "flex items-center gap-2" }, [
+    return h("div", { class: "flex items-center gap-1.5" }, [
       deleteButton,
       chevronIcon
     ]);

package/dist/runtime/domains/auto-form/metadata.d.ts

@@ -0,0 +1,22 @@
+import type { z } from 'zod';
+/**
+ * 应用元数据到 Zod schema
+ */
+export declare function applyMeta<T extends z.ZodType>(schema: T, meta?: unknown): T;
+/**
+ * 从 Zod schema 中提取 AutoForm 元数据
+ *
+ * 通过 BFS 遍历以下路径读取 meta：
+ * - schema.meta() — Zod v4 全局 registry
+ * - schema._zod.parent — .refine()/.check() 创建新实例时设置的父引用
+ * - schema.unwrap() — 可选/默认值等包装类型
+ * - schema.def.innerType / .in / .out / .schema — 结构性内层类型
+ *
+ * 收集所有层级的 meta 并合并，外层优先级更高。
+ */
+export declare function getAutoFormMetadata(schema: z.ZodType): Record<string, any>;
+/**
+ * 提取错误消息和元数据
+ * @returns [errorMessage, metadata]
+ */
+export declare function extractErrorAndMeta(controlMeta?: any): [string | undefined, any];

package/dist/runtime/domains/auto-form/metadata.js

@@ -0,0 +1,53 @@
+import { isObject } from "@movk/core";
+import { AUTOFORM_META } from "./constants.js";
+export function applyMeta(schema, meta) {
+  const normalizedMeta = isObject(meta) ? meta : {};
+  return schema.meta(normalizedMeta);
+}
+export function getAutoFormMetadata(schema) {
+  const queue = [schema];
+  const visited = /* @__PURE__ */ new Set();
+  const collectedMetas = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || visited.has(current))
+      continue;
+    visited.add(current);
+    const meta = typeof current.meta === "function" ? current.meta() : void 0;
+    if (meta && isObject(meta)) {
+      const typedMeta = meta;
+      const normalizedMeta = typedMeta?.[AUTOFORM_META.KEY] && isObject(typedMeta[AUTOFORM_META.KEY]) ? typedMeta[AUTOFORM_META.KEY] : typedMeta;
+      collectedMetas.push(normalizedMeta);
+    }
+    if (typeof current.unwrap === "function") {
+      try {
+        queue.push(current.unwrap());
+      } catch {
+      }
+    }
+    if (current?._zod?.parent)
+      queue.push(current._zod.parent);
+    const def = current?.def || current?._def;
+    if (def?.innerType)
+      queue.push(def.innerType);
+    if (def?.in)
+      queue.push(def.in);
+    if (def?.out)
+      queue.push(def.out);
+    if (def?.schema)
+      queue.push(def.schema);
+  }
+  if (collectedMetas.length === 0)
+    return {};
+  return Object.assign({}, ...collectedMetas.reverse());
+}
+export function extractErrorAndMeta(controlMeta) {
+  if (typeof controlMeta === "string") {
+    return [controlMeta, void 0];
+  }
+  if (controlMeta && isObject(controlMeta) && "error" in controlMeta) {
+    const { error, ...meta } = controlMeta;
+    return [error, meta];
+  }
+  return [void 0, controlMeta];
+}

package/dist/runtime/domains/auto-form/provider.d.ts

@@ -0,0 +1,62 @@
+import type { Ref } from 'vue';
+import type { ReactiveValue } from '@movk/core';
+import type { AutoFormField, AutoFormMergeMeta, ResolvedAutoFormFieldContext } from '../../types/auto-form';
+type _ResolveReactive<T> = T extends ReactiveValue<infer V, any> ? V : T;
+type ResolvedMetaValue<K extends keyof AutoFormMergeMeta> = _ResolveReactive<NonNullable<AutoFormMergeMeta[K]>>;
+/** 初始化表单上下文工厂并通过 provide 注入给所有子渲染器 */
+export declare function useAutoFormProvider(state: Ref<any>, slots: Record<string, any>): {
+    createFieldContext: (field: AutoFormField, extraProps?: Record<string, any>) => ResolvedAutoFormFieldContext;
+    createSlotProps: (field: AutoFormField, extraProps?: Record<string, any>) => ResolvedAutoFormFieldContext;
+    resolveFieldProp: {
+        <K extends keyof AutoFormMergeMeta>(field: AutoFormField, prop: K, defaultValue?: ResolvedMetaValue<K>, extraProps?: Record<string, any>): ResolvedMetaValue<K> | undefined;
+        <T>(field: AutoFormField, prop: keyof AutoFormMergeMeta, defaultValue?: T, extraProps?: Record<string, any>): T | undefined;
+    };
+    renderFieldSlot: (fn?: (props?: any) => any, slotProps?: any) => any;
+    getResolvedFieldSlots: (field: AutoFormField, extraProps?: Record<string, any>) => Record<string, ((props?: any) => any) | undefined> | undefined;
+    renderControl: (field: AutoFormField, extraProps?: Record<string, any>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | null;
+    createSlotResolver: (field: AutoFormField, extraProps?: Record<string, any>) => {
+        hasSlot(name: string): boolean;
+        renderSlot(name: string, slotProps: any): any;
+    };
+    createFormFieldSlots: (field: AutoFormField, slotResolver: ReturnType<(field: AutoFormField, extraProps?: Record<string, any>) => {
+        hasSlot(name: string): boolean;
+        renderSlot(name: string, slotProps: any): any;
+    }>, extraProps?: Record<string, any>) => Record<string, any>;
+    createCollapsibleEnhancer: (field: AutoFormField, extraProps?: Record<string, any>) => {
+        collapsibleConfig: import("vue").ComputedRef<import("../../types").AutoFormNestedCollapsible | undefined>;
+        shouldShowCollapsible: import("vue").ComputedRef<boolean>;
+        isHidden: import("vue").ComputedRef<boolean | undefined>;
+        enhancedField: import("vue").ComputedRef<AutoFormField>;
+    };
+};
+/** 注入表单上下文，必须在 AutoForm 子渲染器中调用 */
+export declare function useAutoFormInjector(): {
+    createFieldContext: (field: AutoFormField, extraProps?: Record<string, any>) => ResolvedAutoFormFieldContext;
+    createSlotProps: (field: AutoFormField, extraProps?: Record<string, any>) => ResolvedAutoFormFieldContext;
+    resolveFieldProp: {
+        <K extends keyof AutoFormMergeMeta>(field: AutoFormField, prop: K, defaultValue?: ResolvedMetaValue<K>, extraProps?: Record<string, any>): ResolvedMetaValue<K> | undefined;
+        <T>(field: AutoFormField, prop: keyof AutoFormMergeMeta, defaultValue?: T, extraProps?: Record<string, any>): T | undefined;
+    };
+    renderFieldSlot: (fn?: (props?: any) => any, slotProps?: any) => any;
+    getResolvedFieldSlots: (field: AutoFormField, extraProps?: Record<string, any>) => Record<string, ((props?: any) => any) | undefined> | undefined;
+    renderControl: (field: AutoFormField, extraProps?: Record<string, any>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | null;
+    createSlotResolver: (field: AutoFormField, extraProps?: Record<string, any>) => {
+        hasSlot(name: string): boolean;
+        renderSlot(name: string, slotProps: any): any;
+    };
+    createFormFieldSlots: (field: AutoFormField, slotResolver: ReturnType<(field: AutoFormField, extraProps?: Record<string, any>) => {
+        hasSlot(name: string): boolean;
+        renderSlot(name: string, slotProps: any): any;
+    }>, extraProps?: Record<string, any>) => Record<string, any>;
+    createCollapsibleEnhancer: (field: AutoFormField, extraProps?: Record<string, any>) => {
+        collapsibleConfig: import("vue").ComputedRef<import("../../types").AutoFormNestedCollapsible | undefined>;
+        shouldShowCollapsible: import("vue").ComputedRef<boolean>;
+        isHidden: import("vue").ComputedRef<boolean | undefined>;
+        enhancedField: import("vue").ComputedRef<AutoFormField>;
+    };
+};
+export {};

package/dist/runtime/{internal/useAutoFormProvider.js → domains/auto-form/provider.js}

@@ -2,7 +2,7 @@ import { UIcon } from "#components";
 import defu from "defu";
 import { computed, h, inject, isVNode, provide, resolveDynamicComponent, unref } from "vue";
 import { getPath, setPath } from "@movk/core";
-import { enhanceEventProps, resolveReactiveValue } from "../utils/auto-form.js";
+import { enhanceEventProps, resolveReactiveValue } from "./reactive.js";
 const AUTO_FORM_CONTEXT_KEY = Symbol("AUTO_FORM_CONTEXT_KEY");
 export function useAutoFormProvider(state, slots) {
   function createFieldContext(field, extraProps) {
@@ -17,7 +17,8 @@ export function useAutoFormProvider(state, slots) {
       },
       setValue: (pathOrValue, value) => {
         if (value === void 0) {
-          setPath(state.value, path, pathOrValue);
+          const nextValue = typeof pathOrValue === "function" ? pathOrValue(getPath(state.value, path)) : pathOrValue;
+          setPath(state.value, path, nextValue);
         } else {
           const relativePath = String(pathOrValue);
           let fullPath;
@@ -78,10 +79,12 @@ export function useAutoFormProvider(state, slots) {
     const context = createFieldContext(field, extraProps);
     const resolvedControlProps = resolveFieldProp(field, "controlProps", void 0, extraProps) || {};
     const isReadonly = field.decorators?.isReadonly;
+    const resolvedSize = resolveFieldProp(field, "size", void 0, extraProps);
     const finalProps = defu(
       resolvedControlProps,
       isReadonly ? { disabled: true } : {},
-      controlMeta?.mapped?.controlProps || {}
+      controlMeta?.mapped?.controlProps || {},
+      resolvedSize !== void 0 ? { size: resolvedSize } : {}
     );
     const slots2 = defu(
       resolveFieldProp(field, "controlSlots", void 0, extraProps) || {},

package/dist/runtime/domains/auto-form/reactive.d.ts

@@ -0,0 +1,12 @@
+import type { AnyObject } from '@movk/core';
+import type { ResolvedAutoFormFieldContext } from '../../types/auto-form';
+/** 解析单个响应式值：函数则以 context 调用，ref 则解包，否则原样返回 */
+export declare function resolveReactiveValue(value: unknown, context: ResolvedAutoFormFieldContext): any;
+/** 递归解析对象/数组中所有响应式值，VNode 和 ref 不再展开以防止意外渲染 */
+export declare function resolveReactiveObject<T extends Record<string, any>>(obj: T, context: ResolvedAutoFormFieldContext, depth?: number): T;
+/** 为 onXxx 事件 prop 自动追加 context 作为最后一个参数，方便用户在事件回调中访问表单状态 */
+export declare function enhanceEventProps(originalProps: AnyObject, ctx: ResolvedAutoFormFieldContext): Record<string, any>;
+/** 渲染任意 VNode 内容（slot 函数返回值、h() 结果等），单子节点直接返回，多个节点包入 Fragment */
+export declare function VNodeRender(props: {
+    node: unknown;
+}): any;

package/dist/runtime/{utils/reactive-utils.js → domains/auto-form/reactive.js}

@@ -1,6 +1,6 @@
 import { isFunction, isObject } from "@movk/core";
 import { Fragment, h, isRef, isVNode, unref } from "vue";
-import { AUTOFORM_LIMITS, AUTOFORM_PATTERNS } from "../constants/auto-form.js";
+import { AUTOFORM_LIMITS, AUTOFORM_PATTERNS } from "./constants.js";
 function validateContext(context) {
   if (!context || typeof context !== "object") {
     throw new TypeError("AutoFormFieldContext must be a valid object");

package/dist/runtime/domains/auto-form/schema.d.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import type { AutoFormControls, AutoFormField } from '../../types/auto-form';
+import type { ZodAutoFormFieldMeta } from '../../types/zod';
+/** 将 Zod schema 递归解析为 AutoFormField 列表（schema 遍历的核心入口） */
+export declare function introspectSchema(schema: z.ZodType, mapping: AutoFormControls, path: string, globalMeta?: ZodAutoFormFieldMeta): AutoFormField[];
+/** 将含布局标记的 schema 还原为纯字段 schema，用于 Zod 表单校验 */
+export declare function extractPureSchema<T extends z.ZodObject<any, any>>(schema: T): z.ZodObject<any, any>;

package/dist/runtime/{utils/schema-introspector.js → domains/auto-form/schema.js}

@@ -1,14 +1,18 @@
 import { markRaw } from "vue";
-import { z as zod } from "zod/v4";
+import { z as zod } from "zod";
 import { joinPath, startCase, toPath, isFunction, isObject } from "@movk/core";
-import { useAutoForm } from "../composables/useAutoForm.js";
-import { AUTOFORM_LIMITS, AUTOFORM_META } from "../constants/auto-form.js";
+import { getAutoFormMetadata } from "./metadata.js";
+import { AUTOFORM_LIMITS, AUTOFORM_META } from "./constants.js";
+function getUnwrappedSchema(schema) {
+  const def = schema?.def || schema?._def;
+  return def?.innerType || def?.in || def?.schema || void 0;
+}
 function extractDecorators(schema) {
   const decorators = {};
   let cur = schema;
   let coreSchema = schema;
   while (cur) {
-    const def = cur?.def;
+    const def = cur?.def || cur?._def;
     if (!def?.type)
       break;
     switch (def.type) {
@@ -22,9 +26,11 @@ function extractDecorators(schema) {
         decorators.defaultValue = isFunction(def.defaultValue) ? def.defaultValue() : def.defaultValue;
         break;
     }
-    const next = def?.innerType;
+    const next = getUnwrappedSchema(cur);
     if (!next)
       break;
+    if (next === cur)
+      break;
     cur = next;
     coreSchema = next;
   }
@@ -34,7 +40,6 @@ function extractDecorators(schema) {
   return { decorators, coreSchema };
 }
 function extractSchemaInfo(schema, globalMeta, autoGeneratedLabel) {
-  const { getAutoFormMetadata } = useAutoForm();
   const customMeta = getAutoFormMetadata(schema);
   const { decorators, coreSchema } = extractDecorators(schema);
   const computedType = customMeta?.component ? void 0 : customMeta?.type ?? coreSchema?.type;
@@ -47,7 +52,6 @@ function extractSchemaInfo(schema, globalMeta, autoGeneratedLabel) {
     ...globalMeta,
     ...customMeta,
     type: computedType,
-    // 如果有 overwrite,则进行合并
     ...customMeta?.overwrite && isObject(customMeta.overwrite) ? customMeta.overwrite : {}
   };
   return { decorators, mergedMeta, coreSchema };
@@ -162,14 +166,13 @@ export function introspectSchema(schema, mapping, path, globalMeta = {}) {
     if (enumValues && enumValues.length > 0) {
       field.meta.controlProps = {
         items: enumValues,
-        ...field.meta.controlProps || {}
+        ...field.meta.controlProps
       };
     }
   }
   return [field];
 }
 function isLayoutMarker(schema) {
-  const { getAutoFormMetadata } = useAutoForm();
   const meta = getAutoFormMetadata(schema);
   return meta?.type === AUTOFORM_META.LAYOUT_KEY;
 }
@@ -177,7 +180,6 @@ function processLayoutShape(shape) {
   const resultShape = {};
   for (const [key, fieldSchema] of Object.entries(shape)) {
     if (isLayoutMarker(fieldSchema)) {
-      const { getAutoFormMetadata } = useAutoForm();
       const meta = getAutoFormMetadata(fieldSchema);
       const layoutFields = meta?.layout?.fields;
       if (layoutFields && isObject(layoutFields)) {

package/dist/runtime/domains/data-table/columns/constants.d.ts

@@ -0,0 +1,50 @@
+import type { ColumnDef, ColumnMeta, ColumnPinningState, ColumnSizingState, VisibilityState } from '@tanstack/vue-table';
+import type { DataTableDensityPreset, DataTableSizePreset, DataTableTreeSelectionStrategy } from '../../../types/data-table';
+import type { DataTableProps } from '../../../types/data-table/component';
+export declare const DENSITY_PRESETS: Record<DataTableDensityPreset, {
+    th?: string;
+    td?: string;
+}>;
+export declare const SIZE_PRESET_MAP: Record<DataTableSizePreset, number>;
+export interface SpecialColumnDefaults {
+    id: string;
+    fixed?: 'left' | 'right';
+    size?: number;
+    align?: 'left' | 'center' | 'right';
+    header?: string;
+    tdClass?: string;
+}
+export type SpecialColumnType = 'selection' | 'index' | 'expand' | 'row-pinning' | 'actions';
+export declare const SPECIAL_COLUMN_DEFAULTS: Record<SpecialColumnType, SpecialColumnDefaults>;
+export interface ResolvedColumnState<T> {
+    columnDefs: ColumnDef<T, unknown>[];
+    initialPinning: ColumnPinningState;
+    initialVisibility: VisibilityState;
+    initialSizing: ColumnSizingState;
+    hasColumnPinning: boolean;
+    hasColumnResizing: boolean;
+    hasColumnSort: boolean;
+    hasExpandColumn: boolean;
+    selectionMode?: 'single' | 'multiple';
+    selectionStrategy?: DataTableTreeSelectionStrategy;
+    subRowSelection?: boolean;
+    allColumnIds: string[];
+}
+export interface ResolveContext<T> {
+    options: DataTableProps<T>;
+    density: ColumnMeta<T, unknown>['class'] | null;
+    pinning: ColumnPinningState;
+    visibility: VisibilityState;
+    sizing: ColumnSizingState;
+    flags: {
+        hasPinning: boolean;
+        hasResizing: boolean;
+        hasSort: boolean;
+        hasExpand: boolean;
+    };
+    selectionMode?: 'single' | 'multiple';
+    selectionStrategy?: DataTableTreeSelectionStrategy;
+    subRowSelection?: boolean;
+    nextGroupId: () => number;
+    allColumnIds: string[];
+}

package/dist/runtime/domains/data-table/columns/constants.js

@@ -0,0 +1,19 @@
+export const DENSITY_PRESETS = {
+  compact: { td: "px-3 py-1.5", th: "px-3 py-2" },
+  normal: { td: "px-4 py-2.5", th: "px-4 py-3" },
+  comfortable: { td: "p-4", th: "p-4" }
+};
+export const SIZE_PRESET_MAP = {
+  xs: 80,
+  sm: 120,
+  md: 180,
+  lg: 260,
+  xl: 400
+};
+export const SPECIAL_COLUMN_DEFAULTS = {
+  "selection": { id: "__selection", size: 60, align: "center" },
+  "index": { id: "__index", size: 60, align: "center", header: "#", tdClass: "text-muted" },
+  "expand": { id: "__expand", size: 60, align: "center" },
+  "row-pinning": { id: "__row_pinning", size: 60, align: "center" },
+  "actions": { id: "__actions", size: 60, header: "\u64CD\u4F5C", align: "center" }
+};

package/dist/runtime/domains/data-table/columns/resolve-columns.d.ts

@@ -0,0 +1,4 @@
+import type { DataTableColumn } from '../../../types/data-table';
+import type { ResolvedColumnState } from './constants';
+import type { DataTableProps } from '../../../types/data-table/component';
+export declare function resolveColumns<T>(columns: DataTableColumn<T>[], options: DataTableProps<T>): ResolvedColumnState<T>;