@wener/common 2.0.3 → 2.0.5

package/src/schema/formatZodError.ts

@@ -1,7 +1,16 @@
-import { ZodError } from 'zod/v4';
+import type { core, ZodError } from 'zod/v4';
 import { findJsonSchemaByPath } from './findJsonSchemaByPath';
 import type { TypeSchema } from './TypeSchema';
 
+// Zod 4 issue types with proper typing
+type ZodIssue = core.$ZodIssue;
+type ZodIssueInvalidType = core.$ZodIssueInvalidType;
+type ZodIssueTooSmall = core.$ZodIssueTooSmall;
+type ZodIssueTooBig = core.$ZodIssueTooBig;
+type ZodIssueInvalidStringFormat = core.$ZodIssueInvalidStringFormat;
+type ZodIssueInvalidValue = core.$ZodIssueInvalidValue;
+type ZodIssueUnrecognizedKeys = core.$ZodIssueUnrecognizedKeys;
+
 export function formatZodError(error: ZodError, schema?: TypeSchema): string {
 	if (!error.issues || error.issues.length === 0) {
 		return error.message || '验证失败';
@@ -34,102 +43,81 @@ export function formatZodError(error: ZodError, schema?: TypeSchema): string {
 	return messages.join('；');
 }
 
-function formatIssueMessage(issue: ZodError['issues'][number], schema?: TypeSchema): string {
+function formatIssueMessage(issue: ZodIssue, _schema?: TypeSchema): string {
 	let message = issue.message;
 
 	// 处理常见的错误类型，生成更友好的消息
-	// Use string comparison to avoid TypeScript narrowing issues with Zod v4
-	const code = issue.code as string;
-	switch (code) {
+	switch (issue.code) {
 		case 'invalid_type': {
-			const invalidTypeIssue = issue as typeof issue & {
-				expected: string;
-				received: string;
-			};
-			if (invalidTypeIssue.received === 'undefined') {
+			const i = issue as ZodIssueInvalidType;
+			// Zod v4 doesn't have 'received' field directly, extract from message
+			const match = issue.message.match(/received (\w+)/);
+			const received = match?.[1];
+			if (received === 'undefined') {
 				message = '必填';
-			} else if (invalidTypeIssue.received === 'null') {
+			} else if (received === 'null') {
 				message = '不能为空';
 			} else {
-				message = issue.message || `期望类型 ${invalidTypeIssue.expected}，但收到 ${invalidTypeIssue.received}`;
+				message = issue.message || `期望类型 ${i.expected}，但收到 ${received}`;
 			}
 			break;
 		}
-		case 'invalid_string': {
-			const invalidStringIssue = issue as typeof issue & {
-				validation?: string;
-			};
-			if (invalidStringIssue.validation === 'email') {
+		case 'invalid_format': {
+			const i = issue as ZodIssueInvalidStringFormat;
+			if (i.format === 'email') {
 				message = '请输入有效的邮箱地址';
-			} else if (invalidStringIssue.validation === 'url') {
+			} else if (i.format === 'url') {
 				message = '请输入有效的 URL';
-			} else if (invalidStringIssue.validation === 'uuid') {
+			} else if (i.format === 'uuid') {
 				message = '请输入有效的 UUID';
-			} else if (invalidStringIssue.validation === 'date') {
+			} else if (i.format === 'date') {
 				message = '请输入有效的日期';
 			}
 			break;
 		}
 		case 'too_small': {
-			const tooSmallIssue = issue as typeof issue & {
-				type: string;
-				minimum: number;
-			};
-			if (tooSmallIssue.type === 'string' && tooSmallIssue.minimum === 1) {
+			const i = issue as ZodIssueTooSmall;
+			if (i.origin === 'string' && i.minimum === 1) {
 				message = '不能为空';
-			} else if (tooSmallIssue.type === 'number') {
-				message = `至少需要 ${tooSmallIssue.minimum}`;
-			} else if (tooSmallIssue.type === 'array') {
-				message = `至少需要 ${tooSmallIssue.minimum} 项`;
+			} else if (i.origin === 'string') {
+				message = `至少需要 ${i.minimum} 个字符`;
+			} else if (i.origin === 'number' || i.origin === 'int') {
+				message = `至少需要 ${i.minimum}`;
+			} else if (i.origin === 'array') {
+				message = `至少需要 ${i.minimum} 项`;
 			}
 			break;
 		}
 		case 'too_big': {
-			const tooBigIssue = issue as typeof issue & {
-				type: string;
-				maximum: number;
-			};
-			if (tooBigIssue.type === 'string') {
-				message = `最多 ${tooBigIssue.maximum} 个字符`;
-			} else if (tooBigIssue.type === 'number') {
-				message = `最多 ${tooBigIssue.maximum}`;
-			} else if (tooBigIssue.type === 'array') {
-				message = `最多 ${tooBigIssue.maximum} 项`;
+			const i = issue as ZodIssueTooBig;
+			if (i.origin === 'string') {
+				message = `最多 ${i.maximum} 个字符`;
+			} else if (i.origin === 'number' || i.origin === 'int') {
+				message = `最多 ${i.maximum}`;
+			} else if (i.origin === 'array') {
+				message = `最多 ${i.maximum} 项`;
 			}
 			break;
 		}
-		case 'invalid_enum_value': {
-			const enumIssue = issue as typeof issue & {
-				options: readonly unknown[];
-			};
-			message = `必须是以下值之一: ${enumIssue.options?.map(String).join(', ') || '未知选项'}`;
+		case 'invalid_value': {
+			const i = issue as ZodIssueInvalidValue;
+			if (i.values.length === 1) {
+				// Single value means it's a literal check
+				message = `必须是 ${String(i.values[0])}`;
+			} else {
+				message = `必须是以下值之一: ${i.values.map(String).join(', ')}`;
+			}
 			break;
 		}
 		case 'unrecognized_keys': {
-			const unrecognizedIssue = issue as typeof issue & {
-				keys: readonly string[];
-			};
-			message = `不支持的字段: ${unrecognizedIssue.keys?.join(', ') || '未知字段'}`;
+			const i = issue as ZodIssueUnrecognizedKeys;
+			message = `不支持的字段: ${i.keys.join(', ')}`;
 			break;
 		}
 		case 'invalid_union': {
 			message = '不符合任何允许的类型';
 			break;
 		}
-		case 'invalid_union_discriminator': {
-			const discriminatorIssue = issue as typeof issue & {
-				options: readonly unknown[];
-			};
-			message = `必须是以下值之一: ${discriminatorIssue.options?.map(String).join(', ') || '未知选项'}`;
-			break;
-		}
-		case 'invalid_literal': {
-			const literalIssue = issue as typeof issue & {
-				expected: unknown;
-			};
-			message = `必须是 ${String(literalIssue.expected)}`;
-			break;
-		}
 		case 'custom': {
 			// 保留自定义错误消息
 			message = issue.message;

package/src/schema/toJsonSchema.ts

@@ -33,7 +33,7 @@ export function toJsonSchema(schema: TypeSchema): JsonSchemaDef {
 							// prefer nullable
 							match(js)
 								.with({ anyOf: [P.select(), { type: 'null' }] }, (select) => {
-									delete js['anyOf'];
+									delete js.anyOf;
 									Object.assign(js, select);
 									js.nullable = true;
 								})
@@ -70,9 +70,9 @@ function visit(js: JsonSchemaDef, f: (js: JsonSchemaDef) => void) {
 	const _visit = (
 		js: JsonSchemaDef,
 		f: (js: JsonSchemaDef) => void,
-		parent: JsonSchemaDef | undefined,
+		_parent: JsonSchemaDef | undefined,
 		path: string[],
-		k?: string,
+		_k?: string,
 	) => {
 		if (!js) {
 			return;
@@ -109,9 +109,9 @@ function visit(js: JsonSchemaDef, f: (js: JsonSchemaDef) => void) {
 	_visit(js, f, undefined, []);
 }
 
-function resolveJsonSchemaDef(
+function _resolveJsonSchemaDef(
 	js: JsonSchemaDef,
-	ctx?: {
+	_ctx?: {
 		parent: JsonSchemaDef;
 		key: string;
 	},
@@ -129,7 +129,7 @@ function resolveJsonSchemaDef(
 			for (const key in schema.properties) {
 				const prop = schema.properties[key];
 				if (prop) {
-					schema.properties[key] = resolveJsonSchemaDef(prop, { parent: schema, key });
+					schema.properties[key] = _resolveJsonSchemaDef(prop, { parent: schema, key });
 				}
 			}
 			return schema;

package/src/schema/validate.ts

@@ -107,7 +107,7 @@ export function parseData<S extends TypeSchema>(schema: S, data: unknown): Schem
 	);
 }
 
-function formatIssues(schema: TypeSchema, issues: Array<ValidationIssue>): string {
+function _formatIssues(_schema: TypeSchema, _issues: Array<ValidationIssue>): string {
 	return '';
 }
 

package/src/utils/buildRedactorFormSchema.ts

@@ -60,10 +60,10 @@ export function buildRedactorFormSchema(
 	};
 }
 
-function buildReversibleRedactText({
+function _buildReversibleRedactText({
 	id,
-	type,
-	key,
+	type: _type,
+	key: _key,
 	timestamp,
 }: {
 	id?: string | number;