@wener/common 2.0.1 → 2.0.3

package/src/schema/formatZodError.ts

@@ -0,0 +1,151 @@
+import { ZodError } from 'zod/v4';
+import { findJsonSchemaByPath } from './findJsonSchemaByPath';
+import type { TypeSchema } from './TypeSchema';
+
+export function formatZodError(error: ZodError, schema?: TypeSchema): string {
+	if (!error.issues || error.issues.length === 0) {
+		return error.message || '验证失败';
+	}
+
+	const messages: string[] = [];
+
+	// Iterate through issues and format each one
+	// We use manual iteration instead of error.format() to have better control
+	// over field name formatting with schema descriptions
+	for (const issue of error.issues) {
+		const formatted = formatIssueMessage(issue, schema);
+		if (formatted) {
+			const path = issue.path.map((p) => (typeof p === 'symbol' ? String(p) : p)) as (string | number)[];
+			let fieldName = formatPath(path);
+
+			// Try to get field description from schema
+			if (schema && path.length > 0) {
+				const fieldPath = path.map(String).join('.');
+				const fieldSchema = findJsonSchemaByPath(schema, fieldPath);
+				if (fieldSchema?.description) {
+					fieldName = fieldSchema.description;
+				}
+			}
+
+			messages.push(`${fieldName}: ${formatted}`);
+		}
+	}
+
+	return messages.join('；');
+}
+
+function formatIssueMessage(issue: ZodError['issues'][number], 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) {
+		case 'invalid_type': {
+			const invalidTypeIssue = issue as typeof issue & {
+				expected: string;
+				received: string;
+			};
+			if (invalidTypeIssue.received === 'undefined') {
+				message = '必填';
+			} else if (invalidTypeIssue.received === 'null') {
+				message = '不能为空';
+			} else {
+				message = issue.message || `期望类型 ${invalidTypeIssue.expected}，但收到 ${invalidTypeIssue.received}`;
+			}
+			break;
+		}
+		case 'invalid_string': {
+			const invalidStringIssue = issue as typeof issue & {
+				validation?: string;
+			};
+			if (invalidStringIssue.validation === 'email') {
+				message = '请输入有效的邮箱地址';
+			} else if (invalidStringIssue.validation === 'url') {
+				message = '请输入有效的 URL';
+			} else if (invalidStringIssue.validation === 'uuid') {
+				message = '请输入有效的 UUID';
+			} else if (invalidStringIssue.validation === 'date') {
+				message = '请输入有效的日期';
+			}
+			break;
+		}
+		case 'too_small': {
+			const tooSmallIssue = issue as typeof issue & {
+				type: string;
+				minimum: number;
+			};
+			if (tooSmallIssue.type === 'string' && tooSmallIssue.minimum === 1) {
+				message = '不能为空';
+			} else if (tooSmallIssue.type === 'number') {
+				message = `至少需要 ${tooSmallIssue.minimum}`;
+			} else if (tooSmallIssue.type === 'array') {
+				message = `至少需要 ${tooSmallIssue.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} 项`;
+			}
+			break;
+		}
+		case 'invalid_enum_value': {
+			const enumIssue = issue as typeof issue & {
+				options: readonly unknown[];
+			};
+			message = `必须是以下值之一: ${enumIssue.options?.map(String).join(', ') || '未知选项'}`;
+			break;
+		}
+		case 'unrecognized_keys': {
+			const unrecognizedIssue = issue as typeof issue & {
+				keys: readonly string[];
+			};
+			message = `不支持的字段: ${unrecognizedIssue.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;
+			break;
+		}
+		default:
+			// 保留原始消息
+			message = issue.message;
+	}
+
+	return message;
+}
+
+function formatPath(path: (string | number)[]): string {
+	if (path.length === 0) {
+		return '表单';
+	}
+	return path.map(String).join('.');
+}

package/src/schema/getSchemaOptions.ts

@@ -1,13 +1,13 @@
 import { deepFreeze } from '@wener/utils';
 import { getSchemaCache } from './getSchemaCache';
-import { toJsonSchema } from './toJsonSchema';
+import { SchemaRegistry } from './SchemaRegistry';
 import type { TypeSchema } from './TypeSchema';
 
 export function getSchemaOptions(s: TypeSchema): Array<{ value: string; label: string }> {
-	let js = toJsonSchema(s);
+	let js = SchemaRegistry.get(s);
 	return getSchemaCache(s, 'options', () => {
 		let out =
-			(js.anyOf || js.oneOf)?.map((v) => {
+			(js.anyOf || js.oneOf)?.map((v: any) => {
 				let value = v.const;
 				return {
 					label: String(v.description || v.title || value),

package/src/schema/index.ts

@@ -4,3 +4,4 @@ export { getSchemaOptions, getSchemaOptionLabel } from './getSchemaOptions';
 export { toJsonSchema } from './toJsonSchema';
 export { findJsonSchemaByPath } from './findJsonSchemaByPath';
 export { createSchemaData } from './createSchemaData';
+export { SchemaRegistry } from './SchemaRegistry';

package/src/utils/buildBaseUrl.ts

@@ -0,0 +1,12 @@
+function joinUrl(baseUrl: string, maybeUrl: string): string {
+	const sanitizedBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+	const sanitizedEndpoint = maybeUrl.startsWith('/') ? maybeUrl.slice(1) : maybeUrl;
+	return `${sanitizedBase}/${sanitizedEndpoint}`;
+}
+
+export function buildBaseUrl(url: string, baseUrl: string | undefined | null): string {
+	if (!baseUrl || /^https?:/.test(url)) {
+		return url;
+	}
+	return joinUrl(baseUrl, url);
+}

package/src/utils/buildRedactorFormSchema.ts

@@ -0,0 +1,85 @@
+import { forEachJsonSchema, type JsonSchemaDef } from '../jsonschema';
+import { toJsonSchema, type TypeSchema } from '../schema';
+
+export const RedactedText = '[redacted]';
+
+export function buildRedactorFormSchema(
+	ts: TypeSchema,
+	{
+		shouldRedact = (schema) => schema['x-sensitive'] === true,
+		replacer = () => RedactedText,
+	}: {
+		shouldRedact?: (schema: JsonSchemaDef) => boolean;
+		replacer?: (key: string, value: any) => any;
+	},
+) {
+	let js = toJsonSchema(ts);
+
+	let paths: string[][] = [];
+
+	forEachJsonSchema(js, (js, { path }) => {
+		if (shouldRedact(js)) {
+			paths.push(path);
+		}
+	});
+	const vis = (root: any, path: string[]) => {
+		switch (root) {
+			case null:
+			case undefined:
+				return;
+		}
+
+		let c = root;
+		for (let i = 0; i < path.length; i++) {
+			let k = path[i];
+			if (c && typeof c === 'object' && k in c) {
+				let v = c[k];
+				if (path.length === 1) {
+					c[k] = replacer(k, v);
+				} else if (Array.isArray(v)) {
+					for (let vv of v) {
+						vis(vv, path.slice(i + 1));
+					}
+				} else {
+					vis(v, path.slice(i + 1));
+				}
+			}
+		}
+	};
+
+	return (root: any) => {
+		if (!paths.length) {
+			return root;
+		}
+
+		paths.forEach((path) => {
+			vis(root, path);
+		});
+
+		return root;
+	};
+}
+
+function buildReversibleRedactText({
+	id,
+	type,
+	key,
+	timestamp,
+}: {
+	id?: string | number;
+	type?: string;
+	key?: string;
+	timestamp?: number | boolean;
+} = {}) {
+	if (!id) {
+		return RedactedText;
+	}
+	if (timestamp === true) {
+		timestamp = Date.now();
+	}
+	return `[redacted ${id}]`;
+}
+
+export function isRedactedText(v: any) {
+	return v === RedactedText || (typeof v === 'string' && v.startsWith('[redacted ') && v.endsWith(']'));
+}

package/src/utils/getEstimateProcessTime.ts

@@ -0,0 +1,36 @@
+type EstimateProcessTimeResult = {
+	eta: number; // estimated time of arrival in seconds
+	elapsed: number; // in seconds
+	endTime: Date; // estimated end time
+	rate: number; // rate of processing in items per second
+};
+
+export function getEstimateProcessTime({
+	total,
+	processed,
+	startTime,
+	elapsed = startTime ? (Date.now() - startTime.getTime()) / 1000 : undefined,
+}: {
+	total?: number;
+	processed?: number;
+	startTime?: Date;
+	elapsed?: number; // in seconds
+}): EstimateProcessTimeResult | undefined {
+	if (typeof total !== 'number' || typeof processed !== 'number' || !elapsed || processed === 0 || processed >= total) {
+		return undefined;
+	}
+	const now = new Date();
+	const rate = processed / elapsed;
+	if (rate === 0) {
+		return undefined;
+	}
+	const remaining = total - processed;
+	const eta = Math.round(remaining / rate);
+	const endTime = new Date(now.getTime() + eta * 1000);
+	return {
+		eta,
+		elapsed,
+		endTime,
+		rate,
+	};
+}

package/src/utils/index.ts

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

package/src/utils/resolveFeatureOptions.ts

@@ -0,0 +1,14 @@
+import { maybeFunction, type MaybeFunction } from '@wener/utils';
+
+export function resolveFeatureOptions<T>(
+	value: boolean | T | undefined | null,
+	defaultValue: MaybeFunction<T>,
+): T | undefined {
+	if (value === false) {
+		return undefined;
+	}
+	if (value === true || value === undefined || value === null) {
+		return maybeFunction(defaultValue);
+	}
+	return value;
+}

package/lib/cn/Mod11Checksum.js

@@ -1,85 +0,0 @@
-/**
- * ISO 7064:1983, MOD 11-2.
- */ function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-export var Mod11Checksum = /*#__PURE__*/ function() {
-    "use strict";
-    function Mod11Checksum() {
-        _class_call_check(this, Mod11Checksum);
-        _define_property(this, "weights", [
-            7,
-            9,
-            10,
-            5,
-            8,
-            4,
-            2,
-            1,
-            6,
-            3,
-            7,
-            9,
-            10,
-            5,
-            8,
-            4,
-            2,
-            1
-        ]);
-    }
-    _create_class(Mod11Checksum, [
-        {
-            key: "validate",
-            value: function validate(s) {
-                return s.at(-1) === this.compute(s.slice(0, s.length - 1));
-            }
-        },
-        {
-            key: "compute",
-            value: function compute(s) {
-                var weights = this.weights;
-                var sum = 0;
-                for(var i = 0; i < s.length; i++){
-                    sum += parseInt(s[i]) * weights[i];
-                }
-                var num = (12 - sum % 11) % 11;
-                if (num < 10) {
-                    return num.toString();
-                } else {
-                    return 'X';
-                }
-            }
-        }
-    ]);
-    return Mod11Checksum;
-}();

package/lib/cn/Mod31Checksum.js

@@ -1,97 +0,0 @@
-/**
- * GB/T 17710（采ISO 7064）的模31校验码
- *
- * Mod31-3
- */ function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-export var Mod31Checksum = /*#__PURE__*/ function() {
-    "use strict";
-    function Mod31Checksum() {
-        _class_call_check(this, Mod31Checksum);
-        _define_property(this, "weights", [
-            1,
-            3,
-            9,
-            27,
-            19,
-            26,
-            16,
-            17,
-            20,
-            29,
-            25,
-            13,
-            8,
-            24,
-            10,
-            30,
-            28
-        ]);
-        _define_property(this, "chars", '0123456789ABCDEFGHJKLMNPQRTUWXY');
-        _define_property(this, "numbers", this.chars.split('').reduce(function(acc, cur, i) {
-            acc[cur] = i;
-            return acc;
-        }, {}));
-    }
-    _create_class(Mod31Checksum, [
-        {
-            key: "toChar",
-            value: function toChar(n) {
-                return this.chars[n];
-            }
-        },
-        {
-            key: "toNumber",
-            value: function toNumber(c) {
-                return this.numbers[c];
-            }
-        },
-        {
-            key: "validate",
-            value: function validate(s) {
-                return s.at(-1) === this.compute(s.slice(0, s.length - 1));
-            }
-        },
-        {
-            key: "compute",
-            value: function compute(s) {
-                var sum = 0;
-                for(var i = 0; i < s.length; i++){
-                    sum += this.numbers[s[i]] * this.weights[i];
-                }
-                return this.toChar(31 - sum % 31);
-            }
-        }
-    ]);
-    return Mod31Checksum;
-}();

package/lib/cn/ResidentIdentityCardNumber.js

@@ -1,50 +0,0 @@
-import { formatDate } from "./formatDate.js";
-import { Mod11Checksum } from "./Mod11Checksum.js";
-(function (ResidentIdentityCardNumber) {
-    ResidentIdentityCardNumber.Checksum = new Mod11Checksum();
-    function parse(s) {
-        var division = s.slice(0, 6);
-        var birthDate = s.slice(6, 14);
-        var sequence = parseInt(s.slice(14, 17), 10);
-        var checksum = s.slice(17, 18);
-        var valid = ResidentIdentityCardNumber.Checksum.validate(s);
-        var sex = sequence % 2 === 1 ? "Male" : "Female";
-        return {
-            division: division,
-            birthDate: birthDate,
-            sequence: sequence,
-            checksum: checksum,
-            valid: valid,
-            sex: sex,
-            male: sex === "Male",
-            female: sex === "Female",
-            age: new Date().getFullYear() - parseInt(birthDate.slice(0, 4), 10)
-        };
-    }
-    /*
-  export const length = 18;
-  export const pattern = /^\d{6}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[0-9Xx]$/;
-   */ ResidentIdentityCardNumber.parse = parse;
-    function format(param) {
-        var division = param.division, birthDate = param.birthDate, sequence = param.sequence, checksum = param.checksum;
-        if (typeof birthDate !== "string") {
-            birthDate = formatDate(birthDate, "yyyyMMDD");
-        }
-        if (birthDate.includes("-")) {
-            birthDate = birthDate.replace(/-/g, "");
-        }
-        typeof sequence === "number" && (sequence = sequence.toString());
-        sequence = sequence.padStart(3, "0");
-        var base = [
-            division,
-            birthDate,
-            sequence
-        ].join("");
-        if (base.length !== 17)
-            throw new Error("Invalid params");
-        checksum || (checksum = ResidentIdentityCardNumber.Checksum.compute(base));
-        return base + checksum;
-    }
-    ResidentIdentityCardNumber.format = format;
-})(ResidentIdentityCardNumber || (ResidentIdentityCardNumber = {}));
-export var ResidentIdentityCardNumber;

package/lib/cn/formatDate.js

@@ -1,13 +0,0 @@
-export function formatDate(date, format) {
-    switch(format){
-        case 'yyyyMMDD':
-            {
-                var year = date.getFullYear();
-                var month = (date.getMonth() + 1).toString().padStart(2, '0');
-                var day = date.getDate().toString().padStart(2, '0');
-                return "".concat(year).concat(month).concat(day);
-            }
-        default:
-            throw new Error("Invalid format");
-    }
-}

package/lib/cn/parseSex.js

@@ -1,20 +0,0 @@
-export function parseSex(s) {
-    if (!s) return undefined;
-    switch(s.toLowerCase()){
-        case '男':
-        case 'male':
-            return {
-                sex: 'Male',
-                male: true,
-                female: false
-            };
-        case '女':
-        case 'female':
-            return {
-                sex: 'Female',
-                male: false,
-                female: true
-            };
-    }
-    return undefined;
-}

package/lib/resource/schema/SchemaRegistry.js

@@ -1,38 +0,0 @@
-import { getGlobalStates } from "@wener/utils";
-import { toJsonSchema } from "../../schema/index.js";
-var types = getGlobalStates("@wener/common/resource/schema/SchemaRegistry", function () {
-    return new Map();
-});
-export function get(needle) {
-    var key = getKey(needle);
-    var found = types.get(key);
-    if (found) {
-        return found;
-    }
-    else {
-        if (typeof needle !== "string") {
-            return toJsonSchema(needle);
-        }
-    }
-    throw new Error("Schema not found: ".concat(key));
-}
-function getKey(s) {
-    var key;
-    if (typeof s === "string") {
-        key = s;
-    }
-    else {
-        var js = toJsonSchema(s);
-        key = js.$id || js.title;
-    }
-    if (!key) {
-        throw new Error("Schema must have $id or title");
-    }
-    return key;
-}
-export function add(def) {
-    types.set(getKey(def), toJsonSchema(def));
-}
-export function set(key, def) {
-    types.set(getKey(key), toJsonSchema(def));
-}

package/lib/resource/schema/SexType.js

@@ -1,10 +0,0 @@
-import { z } from 'zod/v4';
-export var SexType = Object.freeze({
-    __proto__: null,
-    Male: 'Male',
-    Female: 'Female'
-});
-export var SexTypeSchema = z.union([
-    z.literal(SexType.Male).describe('男'),
-    z.literal(SexType.Female).describe('女')
-]).describe('性别');

package/lib/search/AdvanceSearch.js

@@ -1,9 +0,0 @@
-import { formatAdvanceSearch } from "./formatAdvanceSearch.js";
-import { optimizeAdvanceSearch } from "./optimizeAdvanceSearch.js";
-import { parseAdvanceSearch } from "./parseAdvanceSearch.js";
-(function (AdvanceSearch) {
-    AdvanceSearch.parse = parseAdvanceSearch;
-    AdvanceSearch.format = formatAdvanceSearch;
-    AdvanceSearch.optimize = optimizeAdvanceSearch;
-})(AdvanceSearch || (AdvanceSearch = {}));
-export var AdvanceSearch;