@movk/nuxt 1.1.2 → 1.3.0

package/dist/runtime/domains/api/transfer.d.ts

@@ -0,0 +1,69 @@
+import type { FetchContext, FetchOptions } from 'ofetch';
+import type { ApiResponse, MovkApiPublicConfig, RequestToastOptions, TransferRequestOptions, TransferResult } from '../../types/api';
+import type { ResolvedEndpointConfig } from '../../types/api/module';
+import type { useNuxtApp } from '#imports';
+type NuxtApp = ReturnType<typeof useNuxtApp>;
+/**
+ * 预备传输上下文
+ */
+export interface PreparedTransfer {
+    fullUrl: string;
+    headers: Record<string, string>;
+    config: ResolvedEndpointConfig;
+}
+/**
+ * 解析端点 + 拼装 URL + 合并 headers（auth 在前、用户在后，用户优先）
+ */
+export declare function prepareTransfer(publicConfig: MovkApiPublicConfig, url: string, options: TransferRequestOptions): PreparedTransfer;
+/**
+ * 解析下载文件名
+ * @description 优先级：override > content-disposition > URL pathname 末段 > 'download'
+ */
+export declare function resolveFilename(headers: Headers, url: string, override?: string): string;
+/**
+ * 安全解析 JSON 响应
+ * @description content-type 含 application/json 时尝试 JSON.parse；失败或非 JSON 返回 null
+ */
+export declare function tryParseJsonResponse(headers: Headers, text: string): ApiResponse | null;
+/**
+ * 把 XHR 的 getAllResponseHeaders() 字符串解析为标准 Headers
+ */
+export declare function parseXhrHeaders(raw: string): Headers;
+/**
+ * finalizeTransfer 入参
+ */
+export interface FinalizeTransferContext<T> {
+    /** JSON 响应体；纯二进制成功时为 null */
+    raw: ApiResponse | null;
+    /** 无 JSON 时由调用方提供成功/失败判定与默认数据 */
+    fallback?: {
+        isSuccess: boolean;
+        data: T | null;
+        message?: string;
+    };
+    config: ResolvedEndpointConfig;
+    publicConfig: MovkApiPublicConfig;
+    /** 单次请求 toast 覆盖；false 整体禁用 */
+    requestToast: RequestToastOptions | false | undefined;
+    skipBusinessCheck?: boolean;
+    /** 合成的 FetchContext，用于派发 movk:api:* hook */
+    fetchContext: FetchContext;
+}
+/**
+ * 统一处理传输结果：业务校验 → 派发 hook → 触发 toast → 构造 TransferResult
+ *
+ * @description 本函数**不抛异常**，所有错误以 result.error 形式返回，由 composable 自行决定是否 throw。
+ *  中止场景应由调用方在调用本函数前短路，不要进入此函数。
+ */
+export declare function finalizeTransfer<T>(nuxtApp: NuxtApp, ctx: FinalizeTransferContext<T>): Promise<TransferResult<T>>;
+/**
+ * 合成一个最小可用的 FetchContext，供 hook 订阅者使用
+ *
+ * @description 由于上传/下载基于 XHR / fetch，不经 ofetch；此处提供必要字段以与 $api 的 hook 契约对齐。
+ */
+export declare function buildFetchContext(request: string, options: FetchOptions, response?: {
+    status: number;
+    headers: Headers;
+    _data?: unknown;
+}): FetchContext;
+export {};

package/dist/runtime/domains/api/transfer.js

@@ -0,0 +1,81 @@
+import { extractFilename } from "@movk/core";
+import { getAuthHeaders } from "./auth.js";
+import { resolveEndpointConfig } from "./endpoint-config.js";
+import { createApiError } from "./errors.js";
+import { extractData, extractMessage, isBusinessSuccess } from "./response.js";
+import { showToast } from "./toast.js";
+export function prepareTransfer(publicConfig, url, options) {
+  const config = resolveEndpointConfig(publicConfig, options.endpoint);
+  const fullUrl = `${config.baseURL || ""}${url}`;
+  const authHeaders = getAuthHeaders(config.auth);
+  const headers = { ...authHeaders, ...options.headers || {} };
+  return { fullUrl, headers, config };
+}
+export function resolveFilename(headers, url, override) {
+  if (override) return override;
+  const fromHeader = extractFilename(headers, "");
+  if (fromHeader) return fromHeader;
+  try {
+    const base = typeof location !== "undefined" ? location.origin : "http://localhost";
+    const pathname = new URL(url, base).pathname;
+    const last = pathname.split("/").filter(Boolean).pop();
+    if (last) return last;
+  } catch {
+  }
+  return "download";
+}
+export function tryParseJsonResponse(headers, text) {
+  const contentType = headers.get("content-type") || "";
+  if (!contentType.toLowerCase().includes("application/json")) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+export function parseXhrHeaders(raw) {
+  const headers = new Headers();
+  if (!raw) return headers;
+  for (const line of raw.trim().split(/\r?\n/)) {
+    const idx = line.indexOf(":");
+    if (idx <= 0) continue;
+    const name = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (name) headers.append(name, value);
+  }
+  return headers;
+}
+export async function finalizeTransfer(nuxtApp, ctx) {
+  const { raw, fallback, config, publicConfig, requestToast, skipBusinessCheck, fetchContext } = ctx;
+  const { response: responseConfig, toast: toastConfig } = config;
+  if (publicConfig.debug) {
+    console.info("[@movk/nuxt] Transfer response:", raw ?? fallback);
+  }
+  const hasRaw = raw !== null;
+  const isSuccess = hasRaw ? skipBusinessCheck || isBusinessSuccess(raw, responseConfig) : fallback?.isSuccess ?? false;
+  if (isSuccess) {
+    const data = hasRaw ? skipBusinessCheck ? raw : extractData(raw, responseConfig) : fallback?.data ?? null;
+    if (fetchContext.response) {
+      fetchContext.response._data = data;
+    }
+    await nuxtApp.callHook("movk:api:response", fetchContext);
+    showToast("success", raw ?? fallback?.message, requestToast, toastConfig, responseConfig);
+    return { data, error: null, aborted: false };
+  }
+  const message = hasRaw ? extractMessage(raw, responseConfig) || fallback?.message : fallback?.message;
+  const apiError = hasRaw ? createApiError(raw, message) : Object.assign(new Error(message || "\u8BF7\u6C42\u5931\u8D25"), { isBusinessError: false });
+  if (fetchContext.response) {
+    fetchContext.response._data = raw ?? void 0;
+  }
+  fetchContext.error = apiError;
+  await nuxtApp.callHook("movk:api:error", fetchContext);
+  showToast("error", raw ?? message, requestToast, toastConfig, responseConfig);
+  return { data: null, error: apiError, aborted: false };
+}
+export function buildFetchContext(request, options, response) {
+  return {
+    request,
+    options,
+    response
+  };
+}

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

@@ -0,0 +1,2 @@
+import type { SearchFormAction } from '../../types/auto-form/search-form';
+export declare const DEFAULT_SEARCH_ACTIONS: SearchFormAction[];

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

@@ -0,0 +1,4 @@
+export const DEFAULT_SEARCH_ACTIONS = [
+  { key: "search", label: "\u641C\u7D22", icon: "i-lucide-search", type: "submit" },
+  { key: "reset", label: "\u91CD\u7F6E", icon: "i-lucide-rotate-ccw", color: "neutral", variant: "outline" }
+];

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

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

package/dist/runtime/{components/auto-form-renderer/AutoFormRendererArray.vue → domains/auto-form/components/Array.vue}

@@ -1,42 +1,34 @@
 <script setup>
 import { UButton, UCollapsible } from "#components";
-import { computed, ref, unref } from "vue";
-import { useAutoFormInjector } from "../../internal/useAutoFormProvider";
+import { computed, ref } from "vue";
+import { useAutoFormInjector } from "../provider";
 import { joinPath } from "@movk/core";
-import { collectFieldDefaults, createHintSlotFactory, VNodeRender } from "../../utils/auto-form";
-import AutoFormRendererField from "./AutoFormRendererField.vue";
-import AutoFormRendererNested from "./AutoFormRendererNested.vue";
-const {
-  extraProps,
-  field,
-  schema,
-  addButtonProps: customAddButtonProps
-} = defineProps({
+import { collectFieldDefaults, createHintSlotFactory } from "../fields";
+import { VNodeRender } from "../reactive";
+import AutoFormRendererField from "./Field.vue";
+import AutoFormRendererNested from "./Nested.vue";
+const props = defineProps({
+  schema: { type: null, required: true },
   field: { type: Object, required: true },
   extraProps: { type: Object, required: false },
-  addButtonProps: { type: Object, required: false },
-  schema: { type: null, required: false }
-});
-const { createCollapsibleEnhancer, createFieldContext, createSlotResolver, createSlotProps } = useAutoFormInjector();
-const context = createFieldContext(field);
-const slotResolver = computed(() => createSlotResolver(field, extraProps));
-const slotProps = computed(() => createSlotProps(field, extraProps));
-const elementTemplate = computed(() => field.arrayElement);
-const isObjectElement = computed(() => {
-  if (!elementTemplate.value)
-    return false;
-  return elementTemplate.value.meta.type === "object";
+  addButtonProps: { type: Object, required: false }
 });
+const { createCollapsibleEnhancer, createFieldContext, createSlotResolver, createSlotProps, resolveFieldProp } = useAutoFormInjector();
+const context = createFieldContext(props.field);
+const slotResolver = computed(() => createSlotResolver(props.field, props.extraProps));
+const slotProps = computed(() => createSlotProps(props.field, props.extraProps));
+const elementTemplate = computed(() => props.field.arrayElement);
+const isObjectElement = computed(() => elementTemplate.value?.meta.type === "object");
 const arrayValue = computed(() => {
   const value = context.value;
   return Array.isArray(value) ? value : [];
 });
 const itemIds = ref([]);
-let idCounter = 0;
+const idCounter = ref(0);
 function ensureItemIds() {
   const arr = arrayValue.value;
   while (itemIds.value.length < arr.length) {
-    itemIds.value.push(`${field.path}-${idCounter++}`);
+    itemIds.value.push(`${props.field.path}-${idCounter.value++}`);
   }
 }
 function getItemId(_item, index) {
@@ -55,7 +47,7 @@ function updateFieldPaths(template, oldBasePath, newBasePath, hintSlotFactory) {
       fieldSlots: isNested && !isObject ? {
         ...template.meta?.fieldSlots
       } : {
-        hint: (props) => hintSlotFactory(template, props.path, props.open, props.count),
+        hint: (props2) => hintSlotFactory(template, props2.path, props2.open, props2.count),
         ...template.meta?.fieldSlots
       }
     }
@@ -68,23 +60,22 @@ function updateFieldPaths(template, oldBasePath, newBasePath, hintSlotFactory) {
   return updatedField;
 }
 const arrayItemFields = computed(() => {
-  const template = unref(elementTemplate);
+  const template = elementTemplate.value;
   const arr = arrayValue.value;
   if (!template || !arr.length)
     return [];
   const factory = createHintSlotFactory(removeItem);
   return arr.map((_, index) => {
-    const newBasePath = joinPath([field.path, index]);
-    return updateFieldPaths(template, field.path, newBasePath, factory);
+    const newBasePath = joinPath([props.field.path, index]);
+    return updateFieldPaths(template, props.field.path, newBasePath, factory);
   });
 });
 function createDefaultValue() {
-  const template = unref(elementTemplate);
+  const template = elementTemplate.value;
   return template ? collectFieldDefaults(template) : void 0;
 }
 function addItem() {
-  const template = unref(elementTemplate);
-  if (!template)
+  if (!elementTemplate.value)
     return;
   const newArray = [...arrayValue.value, createDefaultValue()];
   context.setValue(newArray);
@@ -97,37 +88,36 @@ function removeItem(count) {
   itemIds.value = [...itemIds.value.slice(0, count), ...itemIds.value.slice(count + 1)];
   context.setValue(newArray);
 }
-const { collapsibleConfig, shouldShowCollapsible, isHidden, enhancedField } = createCollapsibleEnhancer(field, extraProps);
+const { collapsibleConfig, shouldShowCollapsible, isHidden, enhancedField } = createCollapsibleEnhancer(props.field, props.extraProps);
 const DEFAULT_ADD_BUTTON_PROPS = {
   icon: "i-lucide-plus",
-  color: "neutral",
-  variant: "subtle",
-  block: true,
+  color: "info",
+  variant: "soft",
   size: "sm"
 };
 const addButtonProps = computed(() => ({
   ...DEFAULT_ADD_BUTTON_PROPS,
-  ...customAddButtonProps
+  size: resolveFieldProp(props.field, "size", "sm", props.extraProps),
+  ...props.addButtonProps
 }));
 </script>
 
 <template>
   <UCollapsible v-if="shouldShowCollapsible" 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 v-if="elementTemplate" #content>
       <VNodeRender v-if="slotResolver.hasSlot('before')" :node="slotResolver.renderSlot('before', slotProps)" />
       <VNodeRender v-if="slotResolver.hasSlot('content')" :node="slotResolver.renderSlot('content', slotProps)" />
       <template v-else>
-        <template v-for="(item, count) in arrayValue" :key="getItemId(item, count)">
+        <template v-for="(itemField, count) in arrayItemFields" :key="getItemId(arrayValue[count], count)">
           <component
             :is="isObjectElement ? AutoFormRendererNested : AutoFormRendererField"
-            v-if="arrayItemFields[count]"
-            :field="arrayItemFields[count]"
-            :schema="schema"
-            :extra-props="{ ...extraProps, count }"
+            :field="itemField"
+            :schema="props.schema"
+            :extra-props="{ ...props.extraProps, count }"
           />
         </template>
       </template>
@@ -139,13 +129,12 @@ const addButtonProps = computed(() => ({
   </UCollapsible>
 
   <template v-else-if="elementTemplate">
-    <template v-for="(item, count) in arrayValue" :key="getItemId(item, count)">
+    <template v-for="(itemField, count) in arrayItemFields" :key="getItemId(arrayValue[count], count)">
       <component
         :is="isObjectElement ? AutoFormRendererNested : AutoFormRendererField"
-        v-if="arrayItemFields[count]"
-        :field="arrayItemFields[count]"
-        :schema="schema"
-        :extra-props="{ ...extraProps, count }"
+        :field="itemField"
+        :schema="props.schema"
+        :extra-props="{ ...props.extraProps, count }"
       />
     </template>
     <UButton v-bind="addButtonProps" @click="addItem">

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

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

package/dist/runtime/domains/auto-form/components/Children.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 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/Children.vue

@@ -0,0 +1,50 @@
+<script setup>
+import { computed } from "vue";
+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 }
+});
+const fieldTypeMap = computed(() => {
+  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");
+  for (const f of layoutFields) map.set(f, "layout");
+  return map;
+});
+</script>
+
+<template>
+  <template v-for="childField in props.fields" :key="childField.path">
+    <AutoFormRendererField
+      v-if="fieldTypeMap.get(childField) === 'leaf'"
+      :field="childField"
+      :schema="props.schema"
+      :extra-props="props.extraProps"
+    />
+    <AutoFormRendererArray
+      v-else-if="fieldTypeMap.get(childField) === 'array'"
+      :field="childField"
+      :schema="props.schema"
+      :extra-props="props.extraProps"
+    />
+    <AutoFormRendererLayout
+      v-else-if="fieldTypeMap.get(childField) === 'layout'"
+      :field="childField"
+      :schema="props.schema"
+      :extra-props="props.extraProps"
+    />
+    <AutoFormRendererNested
+      v-else
+      :field="childField"
+      :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/domains/auto-form/components/Layout.vue

@@ -0,0 +1,89 @@
+<script>
+
+</script>
+
+<script setup>
+import { computed, resolveDynamicComponent } from "vue";
+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 }
+});
+const { createFieldContext, resolveFieldProp } = useAutoFormInjector();
+function getFieldName(f) {
+  return f.path.split(".").pop() || f.path;
+}
+const visibleFields = computed(() => {
+  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 (!props.field.meta?.layout?.component) {
+    return "div";
+  }
+  return resolveDynamicComponent(props.field.meta.layout.component);
+});
+const layoutProps = computed(() => {
+  const config = props.field.meta.layout;
+  if (!config) return {};
+  const context = createFieldContext(props.field);
+  return {
+    ...resolveReactiveValue(config.props, context),
+    ...config.class && { class: resolveReactiveValue(config.class, context) }
+  };
+});
+const layoutSlots = computed(() => {
+  const config = props.field.meta.layout;
+  if (!config?.slots) return {};
+  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;
+    return acc;
+  }, {});
+});
+const fieldsBySlot = computed(() => {
+  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);
+    slotMapping = /* @__PURE__ */ new Map();
+    for (const [name, slot] of Object.entries(resolved)) {
+      if (slot && typeof slot === "string") slotMapping.set(name, slot);
+    }
+  } else if (config.fieldSlot) {
+    const slot = resolveReactiveValue(config.fieldSlot, context);
+    if (slot && typeof slot === "string") {
+      slotMapping = /* @__PURE__ */ new Map();
+      for (const f of visibleFields.value) {
+        slotMapping.set(getFieldName(f), slot);
+      }
+    }
+  }
+  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);
+    return map;
+  }, /* @__PURE__ */ new Map());
+});
+</script>
+
+<template>
+  <component :is="layoutComponent" v-bind="layoutProps" v-if="visibleFields.length">
+    <template v-for="(slotFn, slotName) in layoutSlots" :key="`slot-${slotName}`" #[slotName]>
+      <component :is="slotFn" />
+    </template>
+
+    <template v-for="[slotName, fields] in fieldsBySlot.entries()" :key="`fields-${slotName}`" #[slotName]>
+      <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;