@wener/common 2.0.2 → 2.0.3

package/src/cn/parseChineseNumber.test.ts

@@ -0,0 +1,159 @@
+import { expect, test } from 'vitest';
+import { formatChineseAmount } from './formatChineseAmount';
+import { parseChineseNumber } from './parseChineseNumber';
+
+test('parseChineseNumber', () => {
+	for (const [a, b] of [
+		['0', 0],
+		['10000', 10_000],
+		['123', 123],
+		['一万', 10_000],
+		['一万一', 10_001],
+		['一万一百一', 10_101],
+		['一万零一百零一', 10_101],
+		['一千零一十', 1010],
+		['一千零一十一', 1011],
+		['一捌玖', 189],
+		['一百一', 101],
+		['一百九十二', 192],
+		['捌玖', 89],
+		['捌玖零', 890],
+		['零捌玖', 89],
+		['肆仟叁佰陆拾', 4360],
+		// ['陆仟捌佰捌拾捌元肆角贰分', 89],
+	] as const) {
+		expect(parseChineseNumber(a)).toBe(b);
+		console.log(
+			a,
+			b,
+			formatChineseNumber(b),
+			formatChineseAmount0(b) === formatChineseAmount(b),
+			formatChineseAmount0(b),
+			formatChineseAmount(b),
+		);
+	}
+});
+
+function formatChineseNumber(v: number): string {
+	if (v < 0) {
+		return '负' + formatChineseNumber(-v);
+	}
+
+	// 数字对应的中文表示
+	const digits = ['〇', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
+	const units = ['', '十', '百', '千'];
+	const bigUnits = ['', '万', '亿', '兆'];
+
+	if (v < 10) {
+		return digits[v];
+	}
+
+	// 将数字分割成千位分隔的数组
+	let parts = [];
+	while (v > 0) {
+		parts.push(v % 10000);
+		v = Math.floor(v / 10000);
+	}
+
+	// 从最高位开始处理每个部分
+	let result = parts
+		.map((part, idx) => {
+			let str = '';
+			let zeroFlag = false; // 标记是否需要添加零
+
+			for (let i = 0; part > 0; i++) {
+				let currentDigit = part % 10;
+				if (currentDigit !== 0) {
+					str = digits[currentDigit] + (i > 0 ? units[i] : '') + str;
+					zeroFlag = true; // 若当前位不为零，则后面可能需要加零
+				} else if (zeroFlag) {
+					str = digits[0] + str; // 加零操作
+					zeroFlag = false; // 重置零标志
+				}
+				part = Math.floor(part / 10);
+			}
+
+			// 返回处理后的字符串，加上相应的大单位
+			return str + bigUnits[idx];
+		})
+		.reverse()
+		.join('')
+		.replace(/〇+/g, '〇')
+		.replace(/〇([万亿兆])/g, '$1');
+
+	// 处理连续〇的情况以及〇位于大单位前的情况
+	return result;
+}
+
+export function formatChineseAmount0(amount: number): string {
+	// 检查金额是否合理
+	if (amount < 0) {
+		return '(负)' + formatChineseAmount0(-amount);
+	}
+	// 大写数字和单位
+	const digits = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
+	const basicUnits = ['', '拾', '佰', '仟'];
+	const bigUnits = ['元', '万', '亿'];
+
+	// 转换为整数处理
+	let integerAmount = Math.round(amount * 100); // 转为分为单位
+
+	if (integerAmount === 0) {
+		return '零元整';
+	}
+
+	let result = '';
+
+	// 处理小数部分（分、角）
+	const cents = integerAmount % 100;
+	const jiao = Math.floor(cents / 10);
+	const fen = cents % 10;
+	integerAmount = Math.floor(integerAmount / 100); // 转为元为单位
+
+	if (fen > 0) {
+		result = digits[fen] + '分' + result;
+	}
+	if (jiao > 0) {
+		result = digits[jiao] + '角' + result;
+	}
+	if (cents === 0) {
+		result += '整';
+	}
+
+	// 处理整数部分
+	let unitIndex = 0;
+	let zeroCount = 0;
+	let needZero = false;
+
+	while (integerAmount > 0) {
+		let segment = integerAmount % 10000;
+		let segmentString = '';
+
+		for (let i = 0; i < 4 && segment > 0; i++) {
+			let digit = segment % 10;
+			if (digit === 0) {
+				zeroCount++;
+			} else {
+				if (zeroCount > 0 || needZero) {
+					segmentString = digits[0] + segmentString;
+					zeroCount = 0;
+					needZero = false;
+				}
+				segmentString = digits[digit] + basicUnits[i] + segmentString;
+			}
+			segment = Math.floor(segment / 10);
+		}
+
+		if (segment > 0 || unitIndex === 0 || segmentString !== '') {
+			result = segmentString + bigUnits[unitIndex] + result;
+			needZero = true;
+		}
+		integerAmount = Math.floor(integerAmount / 10000);
+		unitIndex++;
+	}
+
+	// 去除多余的零，调整单位和数位
+	result = result.replace(/零+/g, '零').replace(/零元/, '元').replace(/零万/, '万');
+
+	return result;
+}

package/src/cn/parseChineseNumber.ts

@@ -0,0 +1,97 @@
+const ToNumber: Record<string, number> = {
+	〇: 0,
+	一: 1,
+	二: 2,
+	三: 3,
+	四: 4,
+	五: 5,
+	六: 6,
+	七: 7,
+	八: 8,
+	九: 9,
+	十: 10,
+	百: 100,
+	千: 1000,
+	万: 10_000,
+	零: 0,
+	壹: 1,
+	贰: 2,
+	叁: 3,
+	肆: 4,
+	伍: 5,
+	陆: 6,
+	柒: 7,
+	捌: 8,
+	玖: 9,
+	拾: 10,
+	佰: 100,
+	仟: 1000,
+	0: 0,
+	1: 1,
+	2: 2,
+	3: 3,
+	4: 4,
+	5: 5,
+	6: 6,
+	7: 7,
+	8: 8,
+	9: 9,
+};
+
+// 一万一 -> 10001
+// 一万一百一 -> 10101
+// 一万 -> 10000
+// 10000 -> 10000
+export function parseChineseNumber(s: string | number) {
+	if (typeof s === 'number') {
+		return s;
+	}
+
+	let n = 0;
+	let c = 0;
+	let base = 0;
+	let shouldAddLast = false;
+	for (const char of s.split('').reverse()) {
+		c = ToNumber[char];
+		if (c === undefined) {
+			throw new Error(`无法解析的数字: ${char}`);
+		}
+
+		switch (c) {
+			case 10: {
+				base = 1;
+				break;
+			}
+
+			case 100: {
+				base = 2;
+				break;
+			}
+
+			case 1000: {
+				base = 3;
+				break;
+			}
+
+			case 10_000: {
+				base = 4;
+				break;
+			}
+		}
+
+		//
+		if (c < 10) {
+			n += c * 10 ** base;
+			base++;
+			shouldAddLast = false;
+		} else {
+			shouldAddLast = true;
+		}
+	}
+
+	if (shouldAddLast) {
+		n += c;
+	}
+
+	return n;
+}

package/src/cn/pinyin/cartesianProduct.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'vitest';
+import { cartesianProduct } from './cartesianProduct';
+
+describe('cartesianProduct', () => {
+	test('combines two arrays with multiple elements', () => {
+		expect(
+			cartesianProduct([
+				[1, 2],
+				[3, 4],
+			]),
+		).toEqual([
+			[1, 3],
+			[1, 4],
+			[2, 3],
+			[2, 4],
+		]);
+	});
+
+	test('combines multiple arrays', () => {
+		expect(cartesianProduct([[1, 2], [3], [4, 5]])).toEqual([
+			[1, 3, 4],
+			[1, 3, 5],
+			[2, 3, 4],
+			[2, 3, 5],
+		]);
+	});
+
+	test('handles an empty array input correctly', () => {
+		expect(cartesianProduct([])).toEqual([]);
+	});
+
+	test('handles one array being empty', () => {
+		expect(cartesianProduct([[1, 2], [], [3]])).toEqual([]);
+	});
+
+	test('works with arrays of different types', () => {
+		expect(
+			cartesianProduct<string | number>([
+				['a', 'b'],
+				[1, 2],
+			]),
+		).toEqual([
+			['a', 1],
+			['a', 2],
+			['b', 1],
+			['b', 2],
+		]);
+	});
+
+	test('handles single-element arrays', () => {
+		expect(cartesianProduct([[1], [2], [3]])).toEqual([[1, 2, 3]]);
+	});
+
+	test('works with more complex objects', () => {
+		expect(cartesianProduct<any>([[{ id: 1 }, { id: 2 }], ['a']])).toEqual([
+			[{ id: 1 }, 'a'],
+			[{ id: 2 }, 'a'],
+		]);
+	});
+
+	test('handles an array containing a single array', () => {
+		expect(cartesianProduct([[1, 2, 3]])).toEqual([[1], [2], [3]]);
+	});
+});

package/src/cn/pinyin/cartesianProduct.ts

@@ -0,0 +1,24 @@
+export function cartesianProduct<T>(args: T[][]): T[][] {
+	if (args.length === 0) return [];
+
+	const product: T[][] = [];
+	const counts = args.map((arr) => arr.length);
+	const counter = new Array(args.length).fill(0);
+	const total = counts.reduce((acc, val) => acc * val, 1);
+
+	for (let i = 0; i < total; i++) {
+		product.push(counter.map((count, index) => args[index][count]));
+
+		// Update the counter for the next row in the Cartesian product.
+		for (let j = args.length - 1; j >= 0; j--) {
+			if (counter[j] + 1 < counts[j]) {
+				counter[j]++;
+				break; // Stop as we've found a digit that can be incremented.
+			} else {
+				counter[j] = 0; // Reset this digit and increment the next digit in the next iteration.
+			}
+		}
+	}
+
+	return product;
+}