@movk/nuxt 1.2.0 → 1.3.0

package/dist/runtime/{components/auto-form-renderer/AutoFormRendererChildren.vue → domains/auto-form/components/Children.vue}

@@ -1,17 +1,17 @@
 <script setup>
 import { computed } from "vue";
-import { classifyFields } from "../../auto-form/field-utils";
-import AutoFormRendererField from "./AutoFormRendererField.vue";
-import AutoFormRendererArray from "./AutoFormRendererArray.vue";
-import AutoFormRendererLayout from "./AutoFormRendererLayout.vue";
-import AutoFormRendererNested from "./AutoFormRendererNested.vue";
-const { fields, schema, extraProps } = defineProps({
+import { classifyFields } from "../fields";
+import AutoFormRendererField from "./Field.vue";
+import AutoFormRendererArray from "./Array.vue";
+import AutoFormRendererLayout from "./Layout.vue";
+import AutoFormRendererNested from "./Nested.vue";
+const props = defineProps({
+  schema: { type: null, required: true },
   fields: { type: Array, required: true },
-  extraProps: { type: Object, required: false },
-  schema: { type: null, required: false }
+  extraProps: { type: Object, required: false }
 });
 const fieldTypeMap = computed(() => {
-  const { leafFields, arrayFields, layoutFields } = classifyFields(fields);
+  const { leafFields, arrayFields, layoutFields } = classifyFields(props.fields);
   const map = /* @__PURE__ */ new Map();
   for (const f of leafFields) map.set(f, "leaf");
   for (const f of arrayFields) map.set(f, "array");
@@ -21,30 +21,30 @@ const fieldTypeMap = computed(() => {
 </script>
 
 <template>
-  <template v-for="childField in fields" :key="childField.path">
+  <template v-for="childField in props.fields" :key="childField.path">
     <AutoFormRendererField
       v-if="fieldTypeMap.get(childField) === 'leaf'"
       :field="childField"
-      :schema="schema"
-      :extra-props="extraProps"
+      :schema="props.schema"
+      :extra-props="props.extraProps"
     />
     <AutoFormRendererArray
       v-else-if="fieldTypeMap.get(childField) === 'array'"
       :field="childField"
-      :schema="schema"
-      :extra-props="extraProps"
+      :schema="props.schema"
+      :extra-props="props.extraProps"
     />
     <AutoFormRendererLayout
       v-else-if="fieldTypeMap.get(childField) === 'layout'"
       :field="childField"
-      :schema="schema"
-      :extra-props="extraProps"
+      :schema="props.schema"
+      :extra-props="props.extraProps"
     />
     <AutoFormRendererNested
       v-else
       :field="childField"
-      :schema="schema"
-      :extra-props="extraProps"
+      :schema="props.schema"
+      :extra-props="props.extraProps"
     />
   </template>
 </template>

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

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

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

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

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

@@ -0,0 +1,56 @@
+<script setup>
+import { UFormField } from "#components";
+import { computed } from "vue";
+import { useAutoFormInjector } from "../provider";
+import { VNodeRender } from "../reactive";
+const props = defineProps({
+  schema: { type: null, required: true },
+  field: { type: Object, required: true },
+  extraProps: { type: Object, required: false }
+});
+const {
+  resolveFieldProp,
+  renderControl,
+  createSlotResolver,
+  createFormFieldSlots,
+  createSlotProps
+} = useAutoFormInjector();
+const slotResolver = computed(() => createSlotResolver(props.field, props.extraProps));
+const fieldProps = computed(() => ({
+  hidden: resolveFieldProp(props.field, "hidden", void 0, props.extraProps),
+  as: resolveFieldProp(props.field, "as", void 0, props.extraProps),
+  name: resolveFieldProp(props.field, "name", props.field.path, props.extraProps),
+  errorPattern: resolveFieldProp(props.field, "errorPattern", void 0, props.extraProps),
+  label: resolveFieldProp(props.field, "label", void 0, props.extraProps),
+  description: resolveFieldProp(props.field, "description", void 0, props.extraProps),
+  help: resolveFieldProp(props.field, "help", void 0, props.extraProps),
+  error: resolveFieldProp(props.field, "error", void 0, props.extraProps),
+  hint: resolveFieldProp(props.field, "hint", void 0, props.extraProps),
+  size: resolveFieldProp(props.field, "size", void 0, props.extraProps),
+  required: resolveFieldProp(props.field, "required", void 0, props.extraProps),
+  eagerValidation: resolveFieldProp(props.field, "eagerValidation", void 0, props.extraProps),
+  validateOnInputDelay: resolveFieldProp(props.field, "validateOnInputDelay", void 0, props.extraProps),
+  orientation: resolveFieldProp(props.field, "orientation", void 0, props.extraProps),
+  class: resolveFieldProp(props.field, "class", void 0, props.extraProps),
+  ui: resolveFieldProp(props.field, "ui", void 0, props.extraProps)
+}));
+const formFieldSlots = computed(() => createFormFieldSlots(props.field, slotResolver.value, props.extraProps));
+const renderedControl = computed(() => renderControl(props.field, props.extraProps));
+const defaultSlotProps = computed(() => createSlotProps(props.field, props.extraProps));
+</script>
+
+<template>
+  <UFormField v-show="!fieldProps.hidden" v-bind="fieldProps">
+    <template v-for="(slotComponent, slotName) in formFieldSlots" :key="slotName" #[slotName]="slotData">
+      <VNodeRender :node="slotComponent(slotData)" />
+    </template>
+
+    <template #default="{ error }">
+      <VNodeRender
+        v-if="slotResolver.hasSlot('default')"
+        :node="slotResolver.renderSlot('default', { ...defaultSlotProps, error })"
+      />
+      <VNodeRender v-else :node="renderedControl" />
+    </template>
+  </UFormField>
+</template>

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

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

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

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

package/dist/runtime/{components/auto-form-renderer/AutoFormRendererLayout.vue → domains/auto-form/components/Layout.vue}

@@ -1,46 +1,46 @@
+<script>
+
+</script>
+
 <script setup>
 import { computed, resolveDynamicComponent } from "vue";
-import { resolveReactiveValue } from "../../auto-form/reactive-utils";
-import { useAutoFormInjector } from "../../auto-form/provider";
-import AutoFormRendererChildren from "./AutoFormRendererChildren.vue";
-const {
-  field,
-  schema,
-  extraProps
-} = defineProps({
+import { resolveReactiveValue } from "../reactive";
+import { useAutoFormInjector } from "../provider";
+import AutoFormRendererChildren from "./Children.vue";
+const props = defineProps({
+  schema: { type: null, required: true },
   field: { type: Object, required: true },
-  extraProps: { type: Object, required: false },
-  schema: { type: null, required: false }
+  extraProps: { type: Object, required: false }
 });
 const { createFieldContext, resolveFieldProp } = useAutoFormInjector();
 function getFieldName(f) {
   return f.path.split(".").pop() || f.path;
 }
 const visibleFields = computed(() => {
-  if (!field.children?.length) return [];
-  return field.children.filter(
+  if (!props.field.children?.length) return [];
+  return props.field.children.filter(
     (f) => f && (f.meta?.if === void 0 || resolveFieldProp(f, "if") === true)
   );
 });
 const layoutComponent = computed(() => {
-  if (!field.meta?.layout?.component) {
+  if (!props.field.meta?.layout?.component) {
     return "div";
   }
-  return resolveDynamicComponent(field.meta.layout.component);
+  return resolveDynamicComponent(props.field.meta.layout.component);
 });
 const layoutProps = computed(() => {
-  const config = field.meta.layout;
+  const config = props.field.meta.layout;
   if (!config) return {};
-  const context = createFieldContext(field);
+  const context = createFieldContext(props.field);
   return {
     ...resolveReactiveValue(config.props, context),
     ...config.class && { class: resolveReactiveValue(config.class, context) }
   };
 });
 const layoutSlots = computed(() => {
-  const config = field.meta.layout;
+  const config = props.field.meta.layout;
   if (!config?.slots) return {};
-  const context = createFieldContext(field);
+  const context = createFieldContext(props.field);
   const resolvedSlots = resolveReactiveValue(config.slots, context);
   return Object.entries(resolvedSlots).reduce((acc, [name, fn]) => {
     if (typeof fn === "function") acc[name] = fn;
@@ -48,10 +48,9 @@ const layoutSlots = computed(() => {
   }, {});
 });
 const fieldsBySlot = computed(() => {
-  const config = field.meta.layout;
-  const fields = visibleFields.value;
-  if (!config || !fields.length) return /* @__PURE__ */ new Map();
-  const context = createFieldContext(field);
+  const config = props.field.meta.layout;
+  if (!config || !visibleFields.value.length) return /* @__PURE__ */ new Map();
+  const context = createFieldContext(props.field);
   let slotMapping;
   if (config.fieldSlots) {
     const resolved = resolveReactiveValue(config.fieldSlots, context);
@@ -63,12 +62,12 @@ const fieldsBySlot = computed(() => {
     const slot = resolveReactiveValue(config.fieldSlot, context);
     if (slot && typeof slot === "string") {
       slotMapping = /* @__PURE__ */ new Map();
-      for (const f of fields) {
+      for (const f of visibleFields.value) {
         slotMapping.set(getFieldName(f), slot);
       }
     }
   }
-  return fields.reduce((map, f) => {
+  return visibleFields.value.reduce((map, f) => {
     const slot = slotMapping?.get(getFieldName(f)) || "default";
     if (!map.has(slot)) map.set(slot, []);
     map.get(slot).push(f);
@@ -84,7 +83,7 @@ const fieldsBySlot = computed(() => {
     </template>
 
     <template v-for="[slotName, fields] in fieldsBySlot.entries()" :key="`fields-${slotName}`" #[slotName]>
-      <AutoFormRendererChildren :fields="fields" :schema="schema" :extra-props="extraProps" />
+      <AutoFormRendererChildren :fields="fields" :schema="props.schema" :extra-props="props.extraProps" />
     </template>
   </component>
 </template>

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

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

package/dist/runtime/domains/auto-form/components/Nested.d.vue.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/{components/auto-form-renderer/AutoFormRendererNested.vue → domains/auto-form/components/Nested.vue}

@@ -1,43 +1,39 @@
 <script setup>
 import { UCollapsible } from "#components";
 import { computed } from "vue";
-import { useAutoFormInjector } from "../../auto-form/provider";
-import { isLeafField } from "../../auto-form/field-utils";
-import { VNodeRender } from "../../auto-form/reactive-utils";
-import AutoFormRendererField from "./AutoFormRendererField.vue";
-import AutoFormRendererChildren from "./AutoFormRendererChildren.vue";
-const {
-  field,
-  schema,
-  extraProps
-} = defineProps({
+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 },
-  schema: { type: null, required: false }
+  extraProps: { type: Object, required: false }
 });
 const { createSlotResolver, createSlotProps, createCollapsibleEnhancer, resolveFieldProp } = useAutoFormInjector();
 const visibleFields = computed(() => {
-  if (isLeafField(field) || !field.children?.length) {
+  if (isLeafField(props.field) || !props.field.children?.length) {
     return [];
   }
-  return field.children.filter(
+  return props.field.children.filter(
     (f) => f && (f.meta?.if === void 0 || resolveFieldProp(f, "if") === true)
   );
 });
-const slotResolver = computed(() => createSlotResolver(field, extraProps));
-const { collapsibleConfig, shouldShowCollapsible, isHidden, enhancedField } = createCollapsibleEnhancer(field, extraProps);
-const slotProps = computed(() => createSlotProps(field, extraProps));
+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="schema" :extra-props="{ ...extraProps, 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="schema" :extra-props="extraProps" />
+      <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>
@@ -45,7 +41,7 @@ const slotProps = computed(() => createSlotProps(field, extraProps));
   <AutoFormRendererChildren
     v-else-if="visibleFields.length"
     :fields="visibleFields"
-    :schema="schema"
-    :extra-props="extraProps"
+    :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/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/{auto-form → domains/auto-form}/controls.js

@@ -1,13 +1,14 @@
-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 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,
@@ -24,7 +25,8 @@ import {
   UCheckboxGroup,
   URadioGroup,
   UInputDate,
-  UInputTime
+  UInputTime,
+  UListbox
 } from "#components";
 const DEFAULT_CONTROL_PROPS = { class: "w-full" };
 export function defineControl(e) {
@@ -45,26 +47,27 @@ const DEFAULT_CONTROL_COMPONENTS = {
   enum: USelect,
   file: UFileUpload,
   calendarDate: DatePicker,
-  datePicker: DatePicker,
-  switch: USwitch,
-  textarea: UTextarea,
-  slider: USlider,
-  pinInput: UPinInput,
-  inputTags: UInputTags,
-  selectMenu: USelectMenu,
-  inputMenu: UInputMenu,
-  checkboxGroup: UCheckboxGroup,
-  radioGroup: URadioGroup,
   inputDate: UInputDate,
   inputTime: UInputTime,
   withClear: WithClear,
   withPasswordToggle: WithPasswordToggle,
   withCopy: WithCopy,
   withCharacterLimit: WithCharacterLimit,
-  asPhoneNumberInput: AsPhoneNumberInput,
   withFloatingLabel: WithFloatingLabel,
-  colorChooser: ColorChooser,
+  asPhoneNumberInput: AsPhoneNumberInput,
+  textarea: UTextarea,
+  switch: USwitch,
+  slider: USlider,
+  selectMenu: USelectMenu,
+  inputMenu: UInputMenu,
+  checkboxGroup: UCheckboxGroup,
+  radioGroup: URadioGroup,
+  inputTags: UInputTags,
+  pinInput: UPinInput,
+  listbox: UListbox,
   starRating: StarRating,
-  slideVerify: SlideVerify
+  colorChooser: ColorChooser,
+  slideVerify: SlideVerify,
+  pillGroup: PillGroup
 };
 export const DEFAULT_CONTROLS = createControlMap(DEFAULT_CONTROL_COMPONENTS);

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

@@ -1,5 +1,7 @@
 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[];

package/dist/runtime/{auto-form/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 = [];

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

@@ -1,5 +1,5 @@
 import { isObject } from "@movk/core";
-import { AUTOFORM_META } from "../constants/auto-form.js";
+import { AUTOFORM_META } from "./constants.js";
 export function applyMeta(schema, meta) {
   const normalizedMeta = isObject(meta) ? meta : {};
   return schema.meta(normalizedMeta);

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/{auto-form → 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 "./reactive-utils.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) || {},