refactor(form): remove unnecessary standard and Yup resolvers, optimize ZodResolver usage

Author: Ohh-889

playground/src/app/(demo)/form/modules/ZodResolver.tsx

@@ -1,7 +1,6 @@
 'use client';
 
-import { useEffect } from 'react';
-import { Button, Card, Form, FormField, Input, createStandardResolver, useForm } from 'soybean-react-ui';
+import { Button, Card, Form, FormField, Input, useForm } from 'soybean-react-ui';
 import { z } from 'zod';
 
 // Define Zod Schema
@@ -32,16 +31,13 @@ const initialValues: Inputs = {
 const ZodResolverDemo = () => {
   const [form] = useForm<Inputs>();
 
-  useEffect(() => {
-    form.use(createStandardResolver(zodSchema));
-  }, [form]);
-
   return (
     <Card title="Form with ZodResolver">
       <Form
         className="w-[480px] max-sm:w-full space-y-4"
         form={form}
         initialValues={initialValues}
+        schema={zodSchema}
       >
         <FormField
           label="Username"

primitives/filed-form /src/form-core/resolver/resolver.ts

@@ -0,0 +1,27 @@
+import type { Middleware } from '../middleware';
+
+import type { StandardSchemaV1, StandardSchemaV1NormalizedIssue } from './standard';
+import { createStandardResolver, isStandardSchema } from './standard';
+import { createGenericResolver } from './utils';
+
+export type FormSchema<Values = any> =
+  | StandardSchemaV1<Values>
+  | ((state: Values, name: string | string[] | undefined) => Promise<StandardSchemaV1NormalizedIssue[]>);
+
+function noopMiddleware<Values = any>(): Middleware<Values> {
+  return () => next => action => next(action);
+}
+
+export function resolveSchema<Values = any>(schema: FormSchema<Values>): Middleware<Values> {
+  if (isStandardSchema(schema)) {
+    return createStandardResolver(schema);
+  }
+
+  if (typeof schema === 'function') {
+    return createGenericResolver(schema);
+  }
+
+  console.warn('[resolveSchema] Unsupported schema type, ignored:', schema);
+
+  return noopMiddleware();
+}

primitives/filed-form /src/form-core/resolver/standard.ts

@@ -1,10 +1,6 @@
 /* eslint-disable consistent-return */
-import type { AllPathsKeys } from 'skyroc-type-utils';
 
-import { keyOfName } from '../../utils/util';
-import type { Middleware } from '../middleware';
-
-import { dispatchIssues } from './utils';
+import { createGenericResolver } from './utils';
 
 /**
  * The Standard Schema interface.
@@ -113,59 +109,31 @@ interface StandardSchemaV1PathSegment {
   readonly key: PropertyKey;
 }
 
-function isStandardSchema(obj: any): obj is StandardSchemaV1 {
+export function isStandardSchema(obj: any): obj is StandardSchemaV1 {
   return obj && obj['~standard'] && typeof obj['~standard'].validate === 'function';
 }
 
 /**
  * Standard Schema Resolver
  * 支持 sync/async validate，同时处理 validateField 和 validateFields
  */
-export function createStandardResolver<Values = any>(
-  schema: StandardSchemaV1<Values, unknown>
-): Middleware<Values, AllPathsKeys<Values>> {
-  if (!isStandardSchema(schema)) {
-    throw new Error('Invalid StandardSchema object');
-  }
-
-  return ({ dispatch, getState }) =>
-    next =>
-    async action => {
-      if (action.type !== 'validateField' && action.type !== 'validateFields') {
-        return next(action);
-      }
-
-      const state = getState();
-      const result = await Promise.resolve(schema['~standard'].validate(state));
-
-      console.log('result', result);
-
-      if (!('issues' in result)) {
-        // ✅ 没有错误，清空所有
-        dispatch({ entries: [], type: 'setExternalErrors' });
-        return;
-      }
-
-      // 把 issues 转成统一格式
-      const issues: StandardSchemaV1NormalizedIssue[] =
-        result.issues?.map(issue => ({
-          message: issue.message,
-          path: issue.path?.map(seg => (typeof seg === 'object' && 'key' in seg ? String(seg.key) : String(seg))) || []
-        })) || [];
 
-      // === validateField ===
-      if (action.type === 'validateField') {
-        const name = keyOfName(action.name);
+export function createStandardResolver<Values = any>(schema: StandardSchemaV1<Values>) {
+  return createGenericResolver<Values>(async state => {
+    const result = await Promise.resolve(schema['~standard'].validate(state));
 
-        const filtered = issues.filter(it => it.path?.join('.') === name || (it.path?.length === 0 && name === 'root'));
+    if (!('issues' in result)) return [];
 
-        dispatchIssues<Values>(dispatch, filtered);
-        return;
-      }
+    const issues = result.issues?.map(issue => {
+      const path = issue.path
+        ? issue.path.map(seg => (typeof seg === 'object' && 'key' in seg ? String(seg.key) : String(seg)))
+        : [];
+      return {
+        message: issue.message,
+        path
+      };
+    });
 
-      // === validateFields ===
-      if (action.type === 'validateFields') {
-        dispatchIssues<Values>(dispatch, issues);
-      }
-    };
+    return issues || [];
+  });
 }

primitives/filed-form /src/form-core/resolver/utils.ts

@@ -28,23 +28,36 @@ export function dispatchIssues<Values = any>(
   dispatch({ entries, type: 'setExternalErrors' });
 }
 
-/**
- * 工厂函数：生成通用 resolver
- */
-export function createGenericResolver(
-  validate: (state: any, name?: string | string[]) => Promise<StandardSchemaV1NormalizedIssue[]>
-): Middleware {
+export function createGenericResolver<Values = any>(
+  validate: (state: Values, name?: string | string[]) => Promise<StandardSchemaV1NormalizedIssue[]>
+): Middleware<Values> {
   return ({ dispatch, getState }) =>
     next =>
     async action => {
-      if (action.type === 'validateField' || action.type === 'validateFields') {
-        const issues = await validate(getState(), action.name);
+      if (action.type !== 'validateField' && action.type !== 'validateFields') {
+        return next(action);
+      }
 
-        dispatchIssues(dispatch, issues);
+      const state = getState();
+
+      if (action.type === 'validateField') {
+        const name = keyOfName(action.name) as AllPathsKeys<Values>;
+        const issues = await validate(state, name);
+
+        const filtered = issues.filter(it => it.path.join('.') === name);
+
+        if (filtered.length > 0) {
+          dispatchIssues(dispatch, filtered);
+        } else {
+          dispatch({ entries: [[name, []]], type: 'setExternalErrors' });
+        }
 
         return;
       }
 
-      return next(action);
+      if (action.type === 'validateFields') {
+        const issues = await validate(state, action.name?.map(keyOfName));
+        dispatchIssues(dispatch, issues);
+      }
     };
 }