@wener/common 2.0.1 → 2.0.3

package/lib/cn/parseChineseNumber.test.js

@@ -0,0 +1,278 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { expect, test } from "vitest";
+import { formatChineseAmount } from "./formatChineseAmount.js";
+import { parseChineseNumber } from "./parseChineseNumber.js";
+test("parseChineseNumber", function () {
+    for (var _i = 0, _iter = [
+        [
+            "0",
+            0
+        ],
+        [
+            "10000",
+            10000
+        ],
+        [
+            "123",
+            123
+        ],
+        [
+            "\u4E00\u4E07",
+            10000
+        ],
+        [
+            "\u4E00\u4E07\u4E00",
+            10001
+        ],
+        [
+            "\u4E00\u4E07\u4E00\u767E\u4E00",
+            10101
+        ],
+        [
+            "\u4E00\u4E07\u96F6\u4E00\u767E\u96F6\u4E00",
+            10101
+        ],
+        [
+            "\u4E00\u5343\u96F6\u4E00\u5341",
+            1010
+        ],
+        [
+            "\u4E00\u5343\u96F6\u4E00\u5341\u4E00",
+            1011
+        ],
+        [
+            "\u4E00\u634C\u7396",
+            189
+        ],
+        [
+            "\u4E00\u767E\u4E00",
+            101
+        ],
+        [
+            "\u4E00\u767E\u4E5D\u5341\u4E8C",
+            192
+        ],
+        [
+            "\u634C\u7396",
+            89
+        ],
+        [
+            "\u634C\u7396\u96F6",
+            890
+        ],
+        [
+            "\u96F6\u634C\u7396",
+            89
+        ],
+        [
+            "\u8086\u4EDF\u53C1\u4F70\u9646\u62FE",
+            4360
+        ]
+    ]; _i < _iter.length; _i++) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), a = _iter__i[0], b = _iter__i[1];
+        expect(parseChineseNumber(a)).toBe(b);
+        console.log(a, b, formatChineseNumber(b), formatChineseAmount0(b) === formatChineseAmount(b), formatChineseAmount0(b), formatChineseAmount(b));
+    }
+});
+function formatChineseNumber(v) {
+    if (v < 0) {
+        return "\u8D1F" + formatChineseNumber(-v);
+    }
+    // 数字对应的中文表示
+    var digits = [
+        "\u3007",
+        "\u4E00",
+        "\u4E8C",
+        "\u4E09",
+        "\u56DB",
+        "\u4E94",
+        "\u516D",
+        "\u4E03",
+        "\u516B",
+        "\u4E5D"
+    ];
+    var units = [
+        "",
+        "\u5341",
+        "\u767E",
+        "\u5343"
+    ];
+    var bigUnits = [
+        "",
+        "\u4E07",
+        "\u4EBF",
+        "\u5146"
+    ];
+    if (v < 10) {
+        return digits[v];
+    }
+    // 将数字分割成千位分隔的数组
+    var parts = [];
+    while (v > 0) {
+        parts.push(v % 10000);
+        v = Math.floor(v / 10000);
+    }
+    // 从最高位开始处理每个部分
+    var result = parts.map(function (part, idx) {
+        var str = "";
+        var zeroFlag = false; // 标记是否需要添加零
+        for (var i = 0; part > 0; i++) {
+            var 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, "\u3007").replace(/〇([万亿兆])/g, "$1");
+    // 处理连续〇的情况以及〇位于大单位前的情况
+    return result;
+}
+export function formatChineseAmount0(amount) {
+    // 检查金额是否合理
+    if (amount < 0) {
+        return "(\u8D1F)" + formatChineseAmount0(-amount);
+    }
+    // 大写数字和单位
+    var digits = [
+        "\u96F6",
+        "\u58F9",
+        "\u8D30",
+        "\u53C1",
+        "\u8086",
+        "\u4F0D",
+        "\u9646",
+        "\u67D2",
+        "\u634C",
+        "\u7396"
+    ];
+    var basicUnits = [
+        "",
+        "\u62FE",
+        "\u4F70",
+        "\u4EDF"
+    ];
+    var bigUnits = [
+        "\u5143",
+        "\u4E07",
+        "\u4EBF"
+    ];
+    // 转换为整数处理
+    var integerAmount = Math.round(amount * 100); // 转为分为单位
+    if (integerAmount === 0) {
+        return "\u96F6\u5143\u6574";
+    }
+    var result = "";
+    // 处理小数部分（分、角）
+    var cents = integerAmount % 100;
+    var jiao = Math.floor(cents / 10);
+    var fen = cents % 10;
+    integerAmount = Math.floor(integerAmount / 100); // 转为元为单位
+    if (fen > 0) {
+        result = digits[fen] + "\u5206" + result;
+    }
+    if (jiao > 0) {
+        result = digits[jiao] + "\u89D2" + result;
+    }
+    if (cents === 0) {
+        result += "\u6574";
+    }
+    // 处理整数部分
+    var unitIndex = 0;
+    var zeroCount = 0;
+    var needZero = false;
+    while (integerAmount > 0) {
+        var segment = integerAmount % 10000;
+        var segmentString = "";
+        for (var i = 0; i < 4 && segment > 0; i++) {
+            var 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, "\u96F6").replace(/零元/, "\u5143").replace(/零万/, "\u4E07");
+    return result;
+}

package/lib/cn/pinyin/cartesianProduct.js

@@ -0,0 +1,22 @@
+export function cartesianProduct(args) {
+    if (args.length === 0) return [];
+    const product = [];
+    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;
+}
+
+//# sourceMappingURL=cartesianProduct.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cn/pinyin/cartesianProduct.ts"],"sourcesContent":["export function cartesianProduct<T>(args: T[][]): T[][] {\n\tif (args.length === 0) return [];\n\n\tconst product: T[][] = [];\n\tconst counts = args.map((arr) => arr.length);\n\tconst counter = new Array(args.length).fill(0);\n\tconst total = counts.reduce((acc, val) => acc * val, 1);\n\n\tfor (let i = 0; i < total; i++) {\n\t\tproduct.push(counter.map((count, index) => args[index][count]));\n\n\t\t// Update the counter for the next row in the Cartesian product.\n\t\tfor (let j = args.length - 1; j >= 0; j--) {\n\t\t\tif (counter[j] + 1 < counts[j]) {\n\t\t\t\tcounter[j]++;\n\t\t\t\tbreak; // Stop as we've found a digit that can be incremented.\n\t\t\t} else {\n\t\t\t\tcounter[j] = 0; // Reset this digit and increment the next digit in the next iteration.\n\t\t\t}\n\t\t}\n\t}\n\n\treturn product;\n}\n"],"names":["cartesianProduct","args","length","product","counts","map","arr","counter","Array","fill","total","reduce","acc","val","i","push","count","index","j"],"mappings":"AAAA,OAAO,SAASA,iBAAoBC,IAAW;IAC9C,IAAIA,KAAKC,MAAM,KAAK,GAAG,OAAO,EAAE;IAEhC,MAAMC,UAAiB,EAAE;IACzB,MAAMC,SAASH,KAAKI,GAAG,CAAC,CAACC,MAAQA,IAAIJ,MAAM;IAC3C,MAAMK,UAAU,IAAIC,MAAMP,KAAKC,MAAM,EAAEO,IAAI,CAAC;IAC5C,MAAMC,QAAQN,OAAOO,MAAM,CAAC,CAACC,KAAKC,MAAQD,MAAMC,KAAK;IAErD,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,OAAOI,IAAK;QAC/BX,QAAQY,IAAI,CAACR,QAAQF,GAAG,CAAC,CAACW,OAAOC,QAAUhB,IAAI,CAACgB,MAAM,CAACD,MAAM;QAE7D,gEAAgE;QAChE,IAAK,IAAIE,IAAIjB,KAAKC,MAAM,GAAG,GAAGgB,KAAK,GAAGA,IAAK;YAC1C,IAAIX,OAAO,CAACW,EAAE,GAAG,IAAId,MAAM,CAACc,EAAE,EAAE;gBAC/BX,OAAO,CAACW,EAAE;gBACV,OAAO,uDAAuD;YAC/D,OAAO;gBACNX,OAAO,CAACW,EAAE,GAAG,GAAG,uEAAuE;YACxF;QACD;IACD;IAEA,OAAOf;AACR"}

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

@@ -0,0 +1,179 @@
+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
+            ]
+        ]);
+    });
+});