@wener/common 2.0.5 → 2.0.6

package/lib/cn/pinyin/cartesianProduct.test.js

@@ -1,179 +1,79 @@
-import { describe, expect, test } from "vitest";
-import { cartesianProduct } from "./cartesianProduct.js";
-describe("cartesianProduct", function () {
-    test("combines two arrays with multiple elements", function () {
-        expect(cartesianProduct([
-            [
-                1,
-                2
-            ],
-            [
-                3,
-                4
-            ]
-        ])).toEqual([
-            [
-                1,
-                3
-            ],
-            [
-                1,
-                4
-            ],
-            [
-                2,
-                3
-            ],
-            [
-                2,
-                4
-            ]
-        ]);
-    });
-    test("combines multiple arrays", function () {
-        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", function () {
-        expect(cartesianProduct([])).toEqual([]);
-    });
-    test("handles one array being empty", function () {
-        expect(cartesianProduct([
-            [
-                1,
-                2
-            ],
-            [],
-            [
-                3
-            ]
-        ])).toEqual([]);
-    });
-    test("works with arrays of different types", function () {
-        expect(cartesianProduct([
-            [
-                "a",
-                "b"
-            ],
-            [
-                1,
-                2
-            ]
-        ])).toEqual([
-            [
-                "a",
-                1
-            ],
-            [
-                "a",
-                2
-            ],
-            [
-                "b",
-                1
-            ],
-            [
-                "b",
-                2
-            ]
-        ]);
-    });
-    test("handles single-element arrays", function () {
-        expect(cartesianProduct([
-            [
-                1
-            ],
-            [
-                2
-            ],
-            [
-                3
-            ]
-        ])).toEqual([
-            [
-                1,
-                2,
-                3
-            ]
-        ]);
-    });
-    test("works with more complex objects", function () {
-        expect(cartesianProduct([
-            [
-                {
-                    id: 1
-                },
-                {
-                    id: 2
-                }
-            ],
-            [
-                "a"
-            ]
-        ])).toEqual([
-            [
-                {
-                    id: 1
-                },
-                "a"
-            ],
-            [
-                {
-                    id: 2
-                },
-                "a"
-            ]
-        ]);
-    });
-    test("handles an array containing a single array", function () {
-        expect(cartesianProduct([
-            [
-                1,
-                2,
-                3
-            ]
-        ])).toEqual([
-            [
-                1
-            ],
-            [
-                2
-            ],
-            [
-                3
-            ]
-        ]);
-    });
+import { describe, expect, test } from 'vitest';
+import { cartesianProduct } from './cartesianProduct.js';
+
+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([
+				['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([
+				[
+					{
+						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/lib/cn/pinyin/loader.js

@@ -1,14 +1,16 @@
-import { setCharToPinyinTable } from "./toPinyinPure.js";
-import { transformData } from "./transform.js";
+import { setCharToPinyinTable } from './toPinyinPure.js';
+import { transformData } from './transform.js';
 export function loadCharToPinyinTable() {
-    return import("./data.json", {
-        with: {
-            type: "json"
-        }
-    }).then((v) => v.default).then((data) => {
-        let out = transformData(data);
-        setCharToPinyinTable(out);
-        return out;
-    });
+	return import('./data.json', {
+		with: {
+			type: 'json',
+		},
+	})
+		.then((v) => v.default)
+		.then((data) => {
+			let out = transformData(data);
+			setCharToPinyinTable(out);
+			return out;
+		});
 }
 //# sourceMappingURL=loader.js.map

package/lib/cn/pinyin/preload.js

@@ -1,3 +1,4 @@
-import { loadCharToPinyinTable } from "./loader.js";
+import { loadCharToPinyinTable } from './loader.js';
+
 await loadCharToPinyinTable();
 //# sourceMappingURL=preload.js.map

package/lib/cn/pinyin/toPinyin.test.js

@@ -1,167 +1,155 @@
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    }
-    catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    }
-    else {
-        Promise.resolve(value).then(_next, _throw);
-    }
+	try {
+		var info = gen[key](arg);
+		var value = info.value;
+	} catch (error) {
+		reject(error);
+		return;
+	}
+	if (info.done) {
+		resolve(value);
+	} else {
+		Promise.resolve(value).then(_next, _throw);
+	}
 }
 function _async_to_generator(fn) {
-    return function () {
-        var self = this, args = arguments;
-        return new Promise(function (resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
+	return function () {
+		var args = arguments;
+		return new Promise((resolve, reject) => {
+			var gen = fn.apply(this, args);
+			function _next(value) {
+				asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'next', value);
+			}
+			function _throw(err) {
+				asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'throw', err);
+			}
+			_next(undefined);
+		});
+	};
 }
 function _ts_generator(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function () {
-            if (t[0] & 1)
-                throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
-    return d(g, "next", {
-        value: verb(0)
-    }), d(g, "throw", {
-        value: verb(1)
-    }), d(g, "return", {
-        value: verb(2)
-    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
-        value: function () {
-            return this;
-        }
-    }), g;
-    function verb(n) {
-        return function (v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f)
-            throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _)
-            try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-                    return t;
-                if (y = 0, t)
-                    op = [
-                        op[0] & 2,
-                        t.value
-                    ];
-                switch (op[0]) {
-                    case 0:
-                    case 1:
-                        t = op;
-                        break;
-                    case 4:
-                        _.label++;
-                        return {
-                            value: op[1],
-                            done: false
-                        };
-                    case 5:
-                        _.label++;
-                        y = op[1];
-                        op = [
-                            0
-                        ];
-                        continue;
-                    case 7:
-                        op = _.ops.pop();
-                        _.trys.pop();
-                        continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                            _ = 0;
-                            continue;
-                        }
-                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                            _.label = op[1];
-                            break;
-                        }
-                        if (op[0] === 6 && _.label < t[1]) {
-                            _.label = t[1];
-                            t = op;
-                            break;
-                        }
-                        if (t && _.label < t[2]) {
-                            _.label = t[2];
-                            _.ops.push(op);
-                            break;
-                        }
-                        if (t[2])
-                            _.ops.pop();
-                        _.trys.pop();
-                        continue;
-                }
-                op = body.call(thisArg, _);
-            }
-            catch (e) {
-                op = [
-                    6,
-                    e
-                ];
-                y = 0;
-            }
-            finally {
-                f = t = 0;
-            }
-        if (op[0] & 5)
-            throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
+	var f,
+		y,
+		t,
+		_ = {
+			label: 0,
+			sent: () => {
+				if (t[0] & 1) throw t[1];
+				return t[1];
+			},
+			trys: [],
+			ops: [],
+		},
+		g = Object.create((typeof Iterator === 'function' ? Iterator : Object).prototype),
+		d = Object.defineProperty;
+	return (
+		d(g, 'next', {
+			value: verb(0),
+		}),
+		d(g, 'throw', {
+			value: verb(1),
+		}),
+		d(g, 'return', {
+			value: verb(2),
+		}),
+		typeof Symbol === 'function' &&
+			d(g, Symbol.iterator, {
+				value: function () {
+					return this;
+				},
+			}),
+		g
+	);
+	function verb(n) {
+		return (v) => step([n, v]);
+	}
+	function step(op) {
+		if (f) throw new TypeError('Generator is already executing.');
+		while ((g && ((g = 0), op[0] && (_ = 0)), _))
+			try {
+				if (
+					((f = 1),
+					y &&
+						(t = op[0] & 2 ? y['return'] : op[0] ? y['throw'] || ((t = y['return']) && t.call(y), 0) : y.next) &&
+						!(t = t.call(y, op[1])).done)
+				)
+					return t;
+				if (((y = 0), t)) op = [op[0] & 2, t.value];
+				switch (op[0]) {
+					case 0:
+					case 1:
+						t = op;
+						break;
+					case 4:
+						_.label++;
+						return {
+							value: op[1],
+							done: false,
+						};
+					case 5:
+						_.label++;
+						y = op[1];
+						op = [0];
+						continue;
+					case 7:
+						op = _.ops.pop();
+						_.trys.pop();
+						continue;
+					default:
+						if (!((t = _.trys), (t = t.length > 0 && t[t.length - 1])) && (op[0] === 6 || op[0] === 2)) {
+							_ = 0;
+							continue;
+						}
+						if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+							_.label = op[1];
+							break;
+						}
+						if (op[0] === 6 && _.label < t[1]) {
+							_.label = t[1];
+							t = op;
+							break;
+						}
+						if (t && _.label < t[2]) {
+							_.label = t[2];
+							_.ops.push(op);
+							break;
+						}
+						if (t[2]) _.ops.pop();
+						_.trys.pop();
+						continue;
+				}
+				op = body.call(thisArg, _);
+			} catch (e) {
+				op = [6, e];
+				y = 0;
+			} finally {
+				f = t = 0;
+			}
+		if (op[0] & 5) throw op[1];
+		return {
+			value: op[0] ? op[1] : void 0,
+			done: true,
+		};
+	}
 }
-import { assert, test } from "vitest";
-import { loadCharToPinyinTable } from "./loader.js";
-import { toPinyinPure } from "./toPinyinPure.js";
-test("toPinyin", function () {
-    return _async_to_generator(function () {
-        return _ts_generator(this, function (_state) {
-            switch (_state.label) {
-                case 0:
-                    return [
-                        4,
-                        loadCharToPinyinTable()
-                    ];
-                case 1:
-                    _state.sent();
-                    assert.deepEqual(toPinyinPure("\u771F\u601D"), [
-                        "zhen,sai",
-                        "zhen,si"
-                    ]);
-                    return [
-                        2
-                    ];
-            }
-        });
-        // char to py -> 350k
-        // py to char -> 145k
-        // csv -> 96k
-    })();
-});
+
+import { assert, test } from 'vitest';
+import { loadCharToPinyinTable } from './loader.js';
+import { toPinyinPure } from './toPinyinPure.js';
+
+test('toPinyin', () =>
+	_async_to_generator(function () {
+		return _ts_generator(this, (_state) => {
+			switch (_state.label) {
+				case 0:
+					return [4, loadCharToPinyinTable()];
+				case 1:
+					_state.sent();
+					assert.deepEqual(toPinyinPure('\u771F\u601D'), ['zhen,sai', 'zhen,si']);
+					return [2];
+			}
+		});
+		// char to py -> 350k
+		// py to char -> 145k
+		// csv -> 96k
+	})());

package/lib/cn/pinyin/toPinyinPure.js

@@ -1,32 +1,37 @@
-import { cartesianProduct } from "./cartesianProduct.js";
+import { cartesianProduct } from './cartesianProduct.js';
+
 let CharToPinyinTable;
 export function setCharToPinyinTable(table) {
-    CharToPinyinTable = table;
+	CharToPinyinTable = table;
 }
 export function getCharToPinyinTable() {
-    if (!CharToPinyinTable) {
-        return {};
-    }
-    return CharToPinyinTable;
+	if (!CharToPinyinTable) {
+		return {};
+	}
+	return CharToPinyinTable;
 }
-export function toPinyinPureFirst(s, sep = ",") {
-    let tab = getCharToPinyinTable();
-    return s.split("").map((c) => tab[c]?.[0]).filter(Boolean).join(sep);
+export function toPinyinPureFirst(s, sep = ',') {
+	let tab = getCharToPinyinTable();
+	return s
+		.split('')
+		.map((c) => tab[c]?.[0])
+		.filter(Boolean)
+		.join(sep);
 }
-export function toPinyinPure(s, sep = ",") {
-    let tab = getCharToPinyinTable();
-    // ensure order
-    return cartesianProduct(s.split("").map((c) => tab[c] || "")).sort((a, b) => {
-        for (let i = 0; i < a.length; i++) {
-            let x = a[i];
-            let y = b[i];
-            if (x < y)
-                return -1;
-            if (x > y)
-                return 1;
-        }
-        return 0;
-    }).map((v) => v.filter(Boolean).join(sep));
+export function toPinyinPure(s, sep = ',') {
+	let tab = getCharToPinyinTable();
+	// ensure order
+	return cartesianProduct(s.split('').map((c) => tab[c] || ''))
+		.sort((a, b) => {
+			for (let i = 0; i < a.length; i++) {
+				let x = a[i];
+				let y = b[i];
+				if (x < y) return -1;
+				if (x > y) return 1;
+			}
+			return 0;
+		})
+		.map((v) => v.filter(Boolean).join(sep));
 } // export function lookupPinyinPure(s: string): Array<Array<string>> {
 //   return cartesianProductOfArray(s.split('').map(c => Lookup[c]));
 // }