v-uni-app-ui 1.0.4 → 1.0.6

package/components/utils/event-modifiers.ts

@@ -1,139 +0,0 @@
-import { ref, onUnmounted } from 'vue';
-
-// ========== 类型定义 ==========
-
-type TimerHandle = ReturnType<typeof setTimeout>;
-type IntervalHandle = ReturnType<typeof setInterval>;
-
-export interface DebounceOptions {
-	/** 防抖等待时间（毫秒） */
-	wait: number;
-	/** 是否立即执行第一次 */
-	immediate?: boolean;
-}
-
-export interface CooldownOptions {
-	/** 总冷却时间（毫秒） */
-	stabilizationTime: number;
-	/** 每次倒计时减少的值 */
-	degressionTime: number;
-	/** 倒计时更新间隔 */
-	intervalUpdateTime: number;
-	/** 是否在冷却期间点击时重置计时器 */
-	resetOnClick?: boolean;
-	/** 倒计时回调 */
-	onCountdown?: (payload: { remaining: number; total: number }) => void;
-	/** 冷却完成回调 */
-	onComplete?: () => void;
-}
-
-// ========== 防抖 Hook ==========
-
-export function useDebounce<T extends (...args: any[]) => any>(callback: T, options: DebounceOptions) {
-	const timer = ref<TimerHandle | null>(null);
-	const isPending = ref(false);
-
-	function debounce(...args: Parameters<T>) {
-		if (timer.value) clearTimeout(timer.value);
-
-		const shouldCallNow = options.immediate && !isPending.value;
-
-		isPending.value = true;
-		timer.value = setTimeout(() => {
-			if (!options.immediate) {
-				callback(...args);
-			}
-			isPending.value = false;
-		}, options.wait);
-
-		if (shouldCallNow) {
-			callback(...args);
-		}
-	}
-
-	function cancel() {
-		if (timer.value) {
-			clearTimeout(timer.value);
-			timer.value = null;
-		}
-		isPending.value = false;
-	}
-
-	onUnmounted(() => {
-		cancel();
-	});
-
-	return {
-		debounce,
-		cancel,
-		isPending
-	};
-}
-
-// ========== 冷却 Hook ==========
-
-export function useCooldown(options: CooldownOptions) {
-	const countdownTimer = ref<IntervalHandle | null>(null);
-	const cooldownTimer = ref<TimerHandle | null>(null);
-	const countdown = ref(options.stabilizationTime);
-	const isCountingDown = ref(false);
-
-	function stop() {
-		if (countdownTimer.value) {
-			clearInterval(countdownTimer.value);
-			countdownTimer.value = null;
-		}
-		if (cooldownTimer.value) {
-			clearTimeout(cooldownTimer.value);
-			cooldownTimer.value = null;
-		}
-		isCountingDown.value = false;
-	}
-
-	function start() {
-		// 如果已在冷却中且允许重置，则重新开始
-		if (isCountingDown.value && options.resetOnClick) {
-			stop();
-		} else if (isCountingDown.value) {
-			return; // 冷却中且不允许重置，直接返回
-		}
-
-		isCountingDown.value = true;
-		countdown.value = options.stabilizationTime;
-
-		// 立即触发一次
-		options.onCountdown?.({
-			remaining: countdown.value,
-			total: options.stabilizationTime
-		});
-
-		// 倒计时 interval
-		countdownTimer.value = setInterval(() => {
-			countdown.value -= options.degressionTime;
-
-			const remaining = Math.max(0, countdown.value);
-			options.onCountdown?.({ remaining, total: options.stabilizationTime });
-
-			if (countdown.value <= 0) {
-				stop();
-				options.onComplete?.();
-			}
-		}, options.intervalUpdateTime);
-
-		// 冷却结束定时器
-		cooldownTimer.value = setTimeout(() => {
-			isCountingDown.value = false;
-		}, options.stabilizationTime);
-	}
-
-	onUnmounted(() => {
-		stop();
-	});
-
-	return {
-		countdown,
-		isCountingDown,
-		start,
-		stop
-	};
-}

package/components/utils/validator.ts

@@ -1,451 +0,0 @@
-/**
- * 验证器工具
- * 提供常用数据验证函数
- */
-
-// ==================== 基础验证器 ====================
-
-/**
- * 创建枚举值验证器
- * 验证值是否在指定的枚举值列表中
- *
- * @param allowedValues 允许的值数组
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createEnumValidator<T extends string>(allowedValues: readonly T[], errorMessage?: string): (value: any) => value is T {
-	const validator = (value: any): value is T => {
-		const isValid = allowedValues.includes(value as T);
-		if (!isValid && errorMessage) {
-			console.warn(errorMessage, { value, allowedValues });
-		}
-		return isValid;
-	};
-
-	// 为验证器添加元数据
-	validator.allowedValues = allowedValues;
-	validator.errorMessage = errorMessage || `值必须在以下选项中: ${allowedValues.join(', ')}`;
-
-	return validator;
-}
-
-/**
- * 创建数值范围验证器
- * 验证数值是否在指定范围内
- *
- * @param minimum 最小值
- * @param maximum 最大值
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createNumberRangeValidator(minimum: number, maximum: number, errorMessage?: string): (value: number) => boolean {
-	const validator = (value: number): boolean => {
-		const isValid = value >= minimum && value <= maximum;
-		if (!isValid && errorMessage) {
-			console.warn(errorMessage, { value, minimum, maximum });
-		}
-		return isValid;
-	};
-
-	validator.minimum = minimum;
-	validator.maximum = maximum;
-	validator.errorMessage = errorMessage || `数值必须在 ${minimum} 到 ${maximum} 之间`;
-
-	return validator;
-}
-
-/**
- * 创建长度验证器
- * 验证字符串或数组的长度
- *
- * @param minimumLength 最小长度（可选）
- * @param maximumLength 最大长度（可选）
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createLengthValidator(minimumLength?: number, maximumLength?: number, errorMessage?: string): (value: string | any[]) => boolean {
-	const validator = (value: string | any[]): boolean => {
-		const length = value.length;
-
-		if (minimumLength !== undefined && length < minimumLength) {
-			if (errorMessage) console.warn(errorMessage, { length, minimumLength, maximumLength });
-			return false;
-		}
-
-		if (maximumLength !== undefined && length > maximumLength) {
-			if (errorMessage) console.warn(errorMessage, { length, minimumLength, maximumLength });
-			return false;
-		}
-
-		return true;
-	};
-
-	validator.minimumLength = minimumLength;
-	validator.maximumLength = maximumLength;
-	validator.errorMessage = errorMessage || `长度必须在 ${minimumLength || '无限制'} 到 ${maximumLength || '无限制'} 之间`;
-
-	return validator;
-}
-
-/**
- * 创建正则表达式验证器
- * 验证字符串是否匹配指定的正则表达式
- *
- * @param pattern 正则表达式
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createPatternValidator(pattern: RegExp, errorMessage?: string): (value: string) => boolean {
-	const validator = (value: string): boolean => {
-		const isValid = pattern.test(value);
-		if (!isValid && errorMessage) {
-			console.warn(errorMessage, { value, pattern });
-		}
-		return isValid;
-	};
-
-	validator.pattern = pattern;
-	validator.errorMessage = errorMessage || `必须匹配正则表达式: ${pattern}`;
-
-	return validator;
-}
-
-/**
- * 创建必填验证器
- * 验证值是否为非空
- *
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createRequiredValidator(errorMessage?: string): (value: any) => boolean {
-	const validator = (value: any): boolean => {
-		let isValid = false;
-
-		if (value === undefined || value === null) {
-			isValid = false;
-		} else if (typeof value === 'string') {
-			isValid = value.trim() !== '';
-		} else if (Array.isArray(value)) {
-			isValid = value.length > 0;
-		} else if (typeof value === 'object') {
-			isValid = Object.keys(value).length > 0;
-		} else {
-			isValid = true;
-		}
-
-		if (!isValid && errorMessage) {
-			console.warn(errorMessage, { value });
-		}
-
-		return isValid;
-	};
-
-	validator.errorMessage = errorMessage || '此项为必填项';
-
-	return validator;
-}
-
-// ==================== 特定格式验证器 ====================
-
-/**
- * 创建电子邮箱验证器
- * 验证电子邮箱格式
- *
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createEmailValidator(errorMessage?: string): (value: string) => boolean {
-	const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-
-	const validator = (value: string): boolean => {
-		const isValid = emailPattern.test(value);
-		if (!isValid && errorMessage) {
-			console.warn(errorMessage, { value });
-		}
-		return isValid;
-	};
-
-	validator.errorMessage = errorMessage || '请输入有效的电子邮箱地址';
-
-	return validator;
-}
-
-/**
- * 创建手机号码验证器（中国大陆）
- * 验证中国大陆手机号码格式
- *
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createPhoneNumberValidator(errorMessage?: string): (value: string) => boolean {
-	const phonePattern = /^1[3-9]\d{9}$/;
-
-	const validator = (value: string): boolean => {
-		const isValid = phonePattern.test(value);
-		if (!isValid && errorMessage) {
-			console.warn(errorMessage, { value });
-		}
-		return isValid;
-	};
-
-	validator.errorMessage = errorMessage || '请输入有效的手机号码（11位数字）';
-
-	return validator;
-}
-
-/**
- * 创建URL地址验证器
- * 验证URL地址格式
- *
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createUrlValidator(errorMessage?: string): (value: string) => boolean {
-	const urlPattern = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/;
-
-	const validator = (value: string): boolean => {
-		const isValid = urlPattern.test(value);
-		if (!isValid && errorMessage) {
-			console.warn(errorMessage, { value });
-		}
-		return isValid;
-	};
-
-	validator.errorMessage = errorMessage || '请输入有效的URL地址';
-
-	return validator;
-}
-
-/**
- * 创建身份证号码验证器（中国大陆）
- * 验证中国大陆身份证号码格式
- *
- * @param errorMessage 错误提示信息（可选）
- * @returns 验证器函数
- */
-export function createIdCardValidator(errorMessage?: string): (value: string) => boolean {
-	const idCardPattern = /^\d{17}[\dXx]$/;
-
-	const validator = (value: string): boolean => {
-		const isValid = idCardPattern.test(value);
-		if (!isValid && errorMessage) {
-			console.warn(errorMessage, { value });
-		}
-		return isValid;
-	};
-
-	validator.errorMessage = errorMessage || '请输入有效的身份证号码（18位）';
-
-	return validator;
-}
-
-/**
- * 创建数值验证器
- * 验证数值类型和范围
- *
- * @param options 配置选项
- * @returns 验证器函数
- */
-export function createNumberValidator(options?: {
-	minimum?: number;
-	maximum?: number;
-	integerOnly?: boolean;
-	positiveOnly?: boolean;
-	allowZero?: boolean;
-	errorMessage?: string;
-}): (value: number) => boolean {
-	const validator = (value: number): boolean => {
-		// 检查是否为数值
-		if (typeof value !== 'number' || isNaN(value)) {
-			return false;
-		}
-
-		// 检查是否为整数
-		if (options?.integerOnly && !Number.isInteger(value)) {
-			return false;
-		}
-
-		// 检查是否为正数
-		if (options?.positiveOnly && value <= 0) {
-			return false;
-		}
-
-		// 检查是否允许零
-		if (!options?.allowZero && value === 0) {
-			return false;
-		}
-
-		// 检查最小值
-		if (options?.minimum !== undefined && value < options.minimum) {
-			return false;
-		}
-
-		// 检查最大值
-		if (options?.maximum !== undefined && value > options.maximum) {
-			return false;
-		}
-
-		return true;
-	};
-
-	validator.errorMessage = options?.errorMessage || '请输入有效的数值';
-
-	return validator;
-}
-
-// ==================== 组合验证器 ====================
-
-/**
- * 创建组合验证器
- * 将多个验证器组合成一个验证器
- *
- * @param validators 验证器数组
- * @returns 验证器函数
- */
-export function createCombinedValidator<T>(...validators: ((value: T) => boolean)[]): (value: T) => boolean {
-	const validator = (value: T): boolean => {
-		for (const validatorFunc of validators) {
-			if (!validatorFunc(value)) {
-				return false;
-			}
-		}
-		return true;
-	};
-
-	validator.validators = validators;
-
-	return validator;
-}
-
-/**
- * 创建异步验证器
- * 用于需要异步验证的场景
- *
- * @param validator 验证器函数
- * @returns 异步验证器函数
- */
-export function createAsyncValidator<T>(validator: (value: T) => boolean | Promise<boolean>): (value: T) => Promise<boolean> {
-	const asyncValidator = async (value: T): Promise<boolean> => {
-		try {
-			const result = validator(value);
-			return result instanceof Promise ? await result : result;
-		} catch (error) {
-			console.error('验证器执行出错:', error);
-			return false;
-		}
-	};
-
-	return asyncValidator;
-}
-
-// ==================== 预定义验证器集合 ====================
-
-/**
- * 预定义验证器集合
- * 提供常用的验证器函数
- */
-export const Validators = {
-	// 基础验证器
-	enum: createEnumValidator,
-	numberRange: createNumberRangeValidator,
-	length: createLengthValidator,
-	pattern: createPatternValidator,
-	required: createRequiredValidator,
-
-	// 格式验证器
-	email: createEmailValidator,
-	phoneNumber: createPhoneNumberValidator,
-	url: createUrlValidator,
-	idCard: createIdCardValidator,
-	number: createNumberValidator,
-
-	// 组合验证器
-	combine: createCombinedValidator,
-	async: createAsyncValidator,
-
-	// 预定义验证规则
-	// 正整数验证器
-	positiveInteger: createNumberValidator({
-		integerOnly: true,
-		positiveOnly: true,
-		allowZero: false,
-		errorMessage: '请输入正整数'
-	}),
-
-	// 非负整数验证器
-	nonNegativeInteger: createNumberValidator({
-		integerOnly: true,
-		positiveOnly: false,
-		allowZero: true,
-		errorMessage: '请输入非负整数'
-	}),
-
-	// 百分比验证器
-	percentage: createNumberValidator({
-		minimum: 0,
-		maximum: 100,
-		errorMessage: '请输入0到100之间的百分比数值'
-	}),
-
-	// 密码强度验证器（至少8位，包含字母和数字）
-	passwordStrength: createCombinedValidator<string>(
-		createLengthValidator(8, undefined, '密码长度至少8位'),
-		createPatternValidator(/[a-zA-Z]/, '密码必须包含字母'),
-		createPatternValidator(/[0-9]/, '密码必须包含数字')
-	),
-
-	// 用户名验证器（只能包含字母、数字、下划线，3-20位）
-	username: createCombinedValidator<string>(
-		createLengthValidator(3, 20, '用户名长度必须在3到20位之间'),
-		createPatternValidator(/^[a-zA-Z0-9_]+$/, '用户名只能包含字母、数字和下划线')
-	)
-} as const;
-
-// ==================== 验证器工具函数 ====================
-
-/**
- * 验证值是否符合规则
- *
- * @param value 要验证的值
- * @param validator 验证器函数
- * @returns 验证结果
- */
-export function validateValue<T>(value: T, validator: (value: T) => boolean): { isValid: boolean; errorMessage?: string } {
-	const isValid = validator(value);
-
-	return {
-		isValid,
-		errorMessage: isValid ? undefined : (validator as any).errorMessage
-	};
-}
-
-/**
- * 批量验证多个值
- *
- * @param values 值数组
- * @param validator 验证器函数
- * @returns 验证结果数组
- */
-export function validateValues<T>(values: T[], validator: (value: T) => boolean): Array<{ value: T; isValid: boolean; errorMessage?: string }> {
-	return values.map((value) => ({
-		value,
-		...validateValue(value, validator)
-	}));
-}
-
-/**
- * 创建自定义错误消息的验证器
- *
- * @param validator 原始验证器
- * @param customErrorMessage 自定义错误消息
- * @returns 带自定义错误消息的验证器
- */
-export function withCustomErrorMessage<T>(validator: (value: T) => boolean, customErrorMessage: string): (value: T) => boolean {
-	const customValidator = (value: T): boolean => {
-		return validator(value);
-	};
-
-	customValidator.errorMessage = customErrorMessage;
-
-	return customValidator;
-}