@wener/common 2.0.3 → 2.0.6

package/src/schema/TypeSchema.d.ts

@@ -10,23 +10,23 @@ import type { JsonSchemaDef } from '../jsonschema';
 export type TypeSchema<I = unknown, O = I> = TSchema | z.ZodSchema<O, I> | JsonSchemaDef | StandardSchemaV1<I, O>;
 
 export type SchemaOutput<S extends TypeSchema> =
-	S extends StandardSchemaV1<infer I, infer O>
+	S extends StandardSchemaV1<infer _I, infer O>
 		? O
-		: S extends z.ZodSchema<infer O, infer I>
+		: S extends z.ZodSchema<infer O, infer _I>
 			? O
 			: S extends TSchema
 				? TypeBoxStaticEncode<S>
-				: S extends JsonSchemaDef<infer I, infer O>
+				: S extends JsonSchemaDef<infer _I, infer O>
 					? O
 					: never;
 
 export type SchemaInput<S extends TypeSchema> =
-	S extends StandardSchemaV1<infer I, infer O>
+	S extends StandardSchemaV1<infer I, infer _O>
 		? I
-		: S extends z.ZodSchema<infer O, infer I>
+		: S extends z.ZodSchema<infer _O, infer I>
 			? I
 			: S extends TSchema
 				? TypeBoxStaticDecode<S>
-				: S extends JsonSchemaDef<infer I, infer O>
+				: S extends JsonSchemaDef<infer I, infer _O>
 					? I
 					: never;

package/src/schema/createSchemaData.ts

@@ -1,7 +1,7 @@
 import { match, P } from 'ts-pattern';
 import type { JsonSchemaDef } from '../jsonschema';
-import { toJsonSchema } from './toJsonSchema';
 import type { SchemaOutput, TypeSchema } from './TypeSchema';
+import { toJsonSchema } from './toJsonSchema';
 
 export function createSchemaData<S extends TypeSchema>(
 	ts: S,
@@ -54,8 +54,8 @@ function _create(schema: JsonSchemaDef, options: CreateOptions, ctx: { required:
 		.with({ oneOf: P.nonNullable }, (schema) => {
 			return _create(schema.oneOf[0], options, { required: false });
 		})
-		.with({ type: 'string' }, (schema) => '')
-		.with({ type: P.union('number', 'integer') }, (schema) => 0)
+		.with({ type: 'string' }, (_schema) => '')
+		.with({ type: P.union('number', 'integer') }, (_schema) => 0)
 		.with({ type: 'object' }, () => {
 			const out: Record<string, any> = {};
 
@@ -73,8 +73,8 @@ function _create(schema: JsonSchemaDef, options: CreateOptions, ctx: { required:
 			return out;
 		})
 		.with({ type: 'null' }, () => null)
-		.with({ type: 'boolean' }, (schema) => false)
-		.with({ type: 'array' }, (schema) => [])
+		.with({ type: 'boolean' }, (_schema) => false)
+		.with({ type: 'array' }, (_schema) => [])
 		.otherwise(() => {
 			return undefined;
 		});

package/src/schema/findJsonSchemaByPath.ts

@@ -1,6 +1,6 @@
 import { firstOfMaybeArray } from '@wener/utils';
-import { toJsonSchema } from './toJsonSchema';
 import type { TypeSchema } from './TypeSchema';
+import { toJsonSchema } from './toJsonSchema';
 
 export function findJsonSchemaByPath(schema: TypeSchema, objectPath: string) {
 	schema = toJsonSchema(schema);
@@ -14,10 +14,10 @@ export function findJsonSchemaByPath(schema: TypeSchema, objectPath: string) {
 	for (const segment of segments) {
 		// 检查当前 schema 是否是对象类型且有 properties
 		if (
-			currentSchema
-			&& typeof currentSchema === 'object'
-			&& currentSchema.properties
-			&& currentSchema.properties[segment]
+			currentSchema &&
+			typeof currentSchema === 'object' &&
+			currentSchema.properties &&
+			currentSchema.properties[segment]
 		) {
 			currentSchema = currentSchema.properties[segment];
 			continue;

package/src/schema/formatZodError.test.ts

@@ -181,10 +181,11 @@ describe('formatZodError', () => {
 
 	it('should use schema description when available', () => {
 		const schema = z.object({
-			name: z.string().describe('姓名'),
+			name: z.string().min(1).describe('姓名'),
 			email: z.string().email().describe('邮箱地址'),
 		});
 
+		// Use empty string for name (triggers min(1) error) and invalid email
 		const result = schema.safeParse({ name: '', email: 'invalid' });
 		expect(result.success).toBe(false);
 		if (!result.success) {

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/index.ts

@@ -1,7 +1,7 @@
-export type * from './TypeSchema';
-export { isJsonSchema, isZodSchema, isTypeBoxSchema, validate, parseData, type ValidationResult } from './validate';
-export { getSchemaOptions, getSchemaOptionLabel } from './getSchemaOptions';
-export { toJsonSchema } from './toJsonSchema';
-export { findJsonSchemaByPath } from './findJsonSchemaByPath';
 export { createSchemaData } from './createSchemaData';
+export { findJsonSchemaByPath } from './findJsonSchemaByPath';
+export { getSchemaOptionLabel, getSchemaOptions } from './getSchemaOptions';
 export { SchemaRegistry } from './SchemaRegistry';
+export type * from './TypeSchema';
+export { toJsonSchema } from './toJsonSchema';
+export { isJsonSchema, isTypeBoxSchema, isZodSchema, parseData, type ValidationResult, validate } from './validate';

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

@@ -1,4 +1,4 @@
-import { Kind as TypeBoxKind, type TSchema } from '@sinclair/typebox';
+import { type TSchema, Kind as TypeBoxKind } from '@sinclair/typebox';
 import '@sinclair/typebox';
 import { TypeCompiler } from '@sinclair/typebox/compiler';
 import { ifPresent } from '@wener/utils';
@@ -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

@@ -1,5 +1,5 @@
 import { forEachJsonSchema, type JsonSchemaDef } from '../jsonschema';
-import { toJsonSchema, type TypeSchema } from '../schema';
+import { type TypeSchema, toJsonSchema } from '../schema';
 
 export const RedactedText = '[redacted]';
 
@@ -60,10 +60,10 @@ export function buildRedactorFormSchema(
 	};
 }
 
-function buildReversibleRedactText({
+function _buildReversibleRedactText({
 	id,
-	type,
-	key,
+	type: _type,
+	key: _key,
 	timestamp,
 }: {
 	id?: string | number;

package/src/utils/formatNumber.ts

@@ -0,0 +1,18 @@
+/**
+ * Format a number, removing trailing zeros
+ * @param value - number or string convertible to number
+ * @param decimals - decimal places to keep, default 2
+ *
+ * @example
+ * formatNumber(1.50) // "1.5"
+ * formatNumber(1.00) // "1"
+ * formatNumber(1.234) // "1.23"
+ */
+export function formatNumber(value: number | string, decimals = 2): string {
+	const num = typeof value === 'string' ? Number.parseFloat(value) : value;
+	if (Number.isNaN(num)) return String(value);
+	return num
+		.toFixed(decimals)
+		.replace(/(\.\d*?)0+$/, '$1')
+		.replace(/\.$/, '');
+}

package/src/utils/formatPercent.ts

@@ -0,0 +1,17 @@
+import { formatNumber } from './formatNumber';
+
+/**
+ * Format a percentage, removing trailing zeros
+ * @param value - number (0-1 or 0-100)
+ * @param decimals - decimal places to keep, default 2
+ * @param isRatio - whether value is a ratio (0-1), default false
+ *
+ * @example
+ * formatPercent(0.5, 2, true) // "50"
+ * formatPercent(50.00) // "50"
+ * formatPercent(33.33) // "33.33"
+ */
+export function formatPercent(value: number, decimals = 2, isRatio = false): string {
+	const percent = isRatio ? value * 100 : value;
+	return formatNumber(percent, decimals);
+}

package/src/utils/index.ts

@@ -1,5 +1,5 @@
-export { getEstimateProcessTime } from './getEstimateProcessTime';
+export { buildBaseUrl } from './buildBaseUrl';
 
 export { buildRedactorFormSchema } from './buildRedactorFormSchema';
-
-export { buildBaseUrl } from './buildBaseUrl';
+export { formatNumber } from './formatNumber';
+export { getEstimateProcessTime } from './getEstimateProcessTime';

package/src/utils/resolveFeatureOptions.ts

@@ -1,4 +1,4 @@
-import { maybeFunction, type MaybeFunction } from '@wener/utils';
+import { type MaybeFunction, maybeFunction } from '@wener/utils';
 
 export function resolveFeatureOptions<T>(
 	value: boolean | T | undefined | null,