npm - @cloudcome/utils-core - Versions diffs - 1.20.0 → 1.20.1 - Mend

@cloudcome/utils-core 1.20.0 → 1.20.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (58) hide show

package/dist/regexp.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"regexp.cjs","names":[],"sources":["../src/regexp.ts"],"sourcesContent":["const specialRE = /[.+?^=!:${}()\|[\\]/\\\\-]/g;\n\n/\n 编码处理正则表达式\n * @example\n * ```js\n * reEscape('/$')\n * // => '\\\\/\\\\$'\n * ```\n * @param {string} string\n * @returns {string}\n /\nexport function regexpEscape(string: string): string {\n return string.replace(specialRE, '\\\\$&');\n}\n\n// 邮箱\nconst EMAIL_RE = /^\\w+[-+.\\w]@([a-z\\d-]+\\.)+[a-z]{2,5}$/i;\n/*\n 判断字符串是否为邮箱格式，不对邮箱真实性做验证，如域名是否正确等\n * @param {string} value\n * @returns {boolean}\n /\nexport function isEmail(value: string): boolean {\n return EMAIL_RE.test(value);\n}\n\n// 手机号码\nconst PHONE_RE = /^1\\d{10}$/;\n/\n 判断字符串是否为宽松手机格式，即首位为 1 的 11 位数字都属于手机号\n * @param {string} value\n * @returns {boolean}\n /\nexport function isPhone(value: string): boolean {\n return PHONE_RE.test(value);\n}\n\n// 身份证号码\n// http://www.stats.gov.cn/tjsj/tjbz/xzqhdm/\n// [\"北京市\", \"天津市\", \"河北省\", \"山西省\", \"内蒙古自治区\",\n// \"辽宁省\", \"吉林省\", \"黑龙江省\",\n// \"上海市\", \"江苏省\", \"浙江省\", \"安徽省\", \"福建省\", \"江西省\", \"山东省\",\n// \"河南省\", \"湖北省\", \"湖南省\", \"广东省\", \"广西壮族自治区\", \"海南省\",\n// \"重庆市\", \"四川省\", \"贵州省\", \"云南省\", \"西藏自治区\",\n// \"陕西省\", \"甘肃省\", \"青海省\",\"宁夏回族自治区\", \"新疆维吾尔自治区\",\n// \"台湾省\",\n// \"香港特别行政区\", \"澳门特别行政区\"]\n// [\"11\", \"12\", \"13\", \"14\", \"15\",\n// \"21\", \"22\", \"23\",\n// \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\",\n// \"41\", \"42\", \"43\", \"44\", \"45\", \"46\",\n// \"50\", \"51\", \"52\", \"53\", \"54\",\n// \"61\", \"62\", \"63\", \"64\", \"65\",\n// \"71\",\n// \"81\", \"82\"]\n// 91 国外\nconst IDNO_RE =\n /^(1[1-5]\|2[1-3]\|3[1-7]\|4[1-6]\|5[0-4]\|6[1-5]\|7[1]\|8[1-2]\|9[1])\\d{4}(18\|19\|20)\\d{2}[01]\\d[0123]\\d{4}[\\dxX]$/;\n/\n 判断字符串是否为身份证号码格式\n * @param {string} value\n * @returns {boolean}\n /\nexport function isIDNo(value: string): boolean {\n const isSameFormat = IDNO_RE.test(value);\n\n if (!isSameFormat) return false;\n\n const year = Number(value.slice(6, 10));\n const month = Number(value.slice(10, 12));\n const date = Number(value.slice(12, 14));\n const d = new Date(year, month - 1, date);\n const isSameDate ~~=\n~~ d.getFullYear() === year ~~&&\n~~ d.getMonth() + 1 === month ~~&&\n~~ d.getDate() === date;\n\n if (!isSameDate) return false;\n\n // 将身份证号码前面的17位数分别乘以不同的系数；\n // 从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2\n // 将这17位数字和系数相乘的结果相加；\n // 用加出来和除以11，看余数是多少；\n // 余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字；\n // 其分别对应的最后一位身份证的号码为1－0－X－9－8－7－6－5－4－3－2\n // 通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。\n const coefficientList = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];\n const residueList = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];\n let sum = 0;\n\n for (let start = 0; start < 17; start++) {\n sum += Number(value.slice(start, start + 1)) coefficientList[start];\n }\n\n return residueList[sum % 11] === value.slice(-1);\n}\n\n// url\nconst URL_RE = /^https?:\\/\\//i;\n/*\n 判断字符串是否为 url 格式，仅支持 http 协议，支持域名或者 ipV4\n * @param {string} value\n * @returns {boolean}\n /\nexport function isURL(value: string): boolean {\n return URL_RE.test(value);\n}\n\n// ipv4\nconst IPV4_RE ~~=\n~~ /^(?:(?:\\d\|[1-9]\\d\|1\\d\\d\|2[0-4]\\d\|25[0-5])\\.){3}(?:\\d\|[1-9]\\d\|1\\d\\d\|2[0-4]\\d\|25[0-5])$/;\n/\n 判断字符串是否为 IPV4 格式，不对 ip 真实性做验证\n * @param {string} value\n * @returns {boolean}\n /\nexport function isIPV4(value: string): boolean {\n return IPV4_RE.test(value);\n}\n\nconst INTEGER_RE = /^(-?[1-9]\\d\|0)$/;\n/*\n 判断字符串是否为整数（自然数），即 ...,-3,-2,-1,0,1,2,3,...\n * @param {string} value\n * @returns {boolean}\n /\nexport function isInteger(value: string): boolean {\n return INTEGER_RE.test(value);\n}\n\nconst FLOAT_RE = /^-?([1-9]\\d\|0)\\.\\d+$/;\n/*\n 判断字符串是否为浮点数，即必须有小数点的有理数\n * @param {string} value\n * @returns {boolean}\n /\nexport function isFloat(value: string): boolean {\n return FLOAT_RE.test(value);\n}\n\n/\n 判断字符串是否为正确数值，包括整数和浮点数\n * @param {string} value\n * @returns {boolean}\n /\nexport function isNumerical(value: string): boolean {\n return isInteger(value) \|\| isFloat(value);\n}\n\nconst DIGIT_RE = /^\\d+$/;\n/\n 判断字符串是否为数字，例如六位数字短信验证码（093031）\n * @param {string} value\n * @returns {boolean}\n */\nexport function isDigit(value: string): boolean {\n return DIGIT_RE.test(value);\n}\n"],"mappings":";;AAAA,IAAM,YAAY;;;;;;;;;;;AAYlB,SAAgB,aAAa,QAAwB;CACnD,OAAO,OAAO,QAAQ,WAAW,OAAO;;AAI1C,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;AAI7B,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;AAsB7B,IAAM,UACJ;;;;;;AAMF,SAAgB,OAAO,OAAwB;CAG7C,IAAI,CAFiB,QAAQ,KAAK,MAE7B,EAAc,OAAO;CAE1B,MAAM,OAAO,OAAO,MAAM,MAAM,GAAG,GAAG,CAAC;CACvC,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI,GAAG,CAAC;CACzC,MAAM,OAAO,OAAO,MAAM,MAAM,IAAI,GAAG,CAAC;CACxC,MAAM,IAAI,IAAI,KAAK,MAAM,QAAQ,GAAG,KAAK;~~CAMzC~~,IAAI,~~EAJF~~,EAAE,aAAa,KAAK,~~QACpB~~,EAAE,UAAU,GAAG,MAAM,~~SACrB~~,EAAE,SAAS,KAAK,~~OAED~~,OAAO;CASxB,MAAM,kBAAkB;EAAC;EAAG;EAAG;EAAI;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAI;EAAG;EAAG;EAAG;EAAE;CAC7E,MAAM,cAAc;EAAC;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAI;CAC3E,IAAI,MAAM;CAEV,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,SAC9B,OAAO,OAAO,MAAM,MAAM,OAAO,QAAQ,EAAE,CAAC,GAAG,gBAAgB;CAGjE,OAAO,YAAY,MAAM,QAAQ,MAAM,MAAM,GAAG;;AAIlD,IAAM,SAAS;;;;;;AAMf,SAAgB,MAAM,OAAwB;CAC5C,OAAO,OAAO,KAAK,MAAM;;AAI3B,IAAM,~~UACJ~~;;;;;;~~AAMF~~,SAAgB,OAAO,OAAwB;CAC7C,OAAO,QAAQ,KAAK,MAAM;;AAG5B,IAAM,aAAa;;;;;;AAMnB,SAAgB,UAAU,OAAwB;CAChD,OAAO,WAAW,KAAK,MAAM;;AAG/B,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;;;;;;AAQ7B,SAAgB,YAAY,OAAwB;CAClD,OAAO,UAAU,MAAM,IAAI,QAAQ,MAAM;;AAG3C,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM"}
1	+ {"version":3,"file":"regexp.cjs","names":[],"sources":["../src/regexp.ts"],"sourcesContent":["const specialRE = /[.+?^=!:${}()\|[\\]/\\\\-]/g;\n\n/\n 编码处理正则表达式\n * @example\n * ```js\n * reEscape('/$')\n * // => '\\\\/\\\\$'\n * ```\n * @param {string} string\n * @returns {string}\n /\nexport function regexpEscape(string: string): string {\n return string.replace(specialRE, '\\\\$&');\n}\n\n// 邮箱\nconst EMAIL_RE = /^\\w+[-+.\\w]@([a-z\\d-]+\\.)+[a-z]{2,5}$/i;\n/*\n 判断字符串是否为邮箱格式，不对邮箱真实性做验证，如域名是否正确等\n * @param {string} value\n * @returns {boolean}\n /\nexport function isEmail(value: string): boolean {\n return EMAIL_RE.test(value);\n}\n\n// 手机号码\nconst PHONE_RE = /^1\\d{10}$/;\n/\n 判断字符串是否为宽松手机格式，即首位为 1 的 11 位数字都属于手机号\n * @param {string} value\n * @returns {boolean}\n /\nexport function isPhone(value: string): boolean {\n return PHONE_RE.test(value);\n}\n\n// 身份证号码\n// http://www.stats.gov.cn/tjsj/tjbz/xzqhdm/\n// [\"北京市\", \"天津市\", \"河北省\", \"山西省\", \"内蒙古自治区\",\n// \"辽宁省\", \"吉林省\", \"黑龙江省\",\n// \"上海市\", \"江苏省\", \"浙江省\", \"安徽省\", \"福建省\", \"江西省\", \"山东省\",\n// \"河南省\", \"湖北省\", \"湖南省\", \"广东省\", \"广西壮族自治区\", \"海南省\",\n// \"重庆市\", \"四川省\", \"贵州省\", \"云南省\", \"西藏自治区\",\n// \"陕西省\", \"甘肃省\", \"青海省\",\"宁夏回族自治区\", \"新疆维吾尔自治区\",\n// \"台湾省\",\n// \"香港特别行政区\", \"澳门特别行政区\"]\n// [\"11\", \"12\", \"13\", \"14\", \"15\",\n// \"21\", \"22\", \"23\",\n// \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\",\n// \"41\", \"42\", \"43\", \"44\", \"45\", \"46\",\n// \"50\", \"51\", \"52\", \"53\", \"54\",\n// \"61\", \"62\", \"63\", \"64\", \"65\",\n// \"71\",\n// \"81\", \"82\"]\n// 91 国外\nconst IDNO_RE =\n /^(1[1-5]\|2[1-3]\|3[1-7]\|4[1-6]\|5[0-4]\|6[1-5]\|7[1]\|8[1-2]\|9[1])\\d{4}(18\|19\|20)\\d{2}[01]\\d[0123]\\d{4}[\\dxX]$/;\n/\n 判断字符串是否为身份证号码格式\n * @param {string} value\n * @returns {boolean}\n /\nexport function isIDNo(value: string): boolean {\n const isSameFormat = IDNO_RE.test(value);\n\n if (!isSameFormat) return false;\n\n const year = Number(value.slice(6, 10));\n const month = Number(value.slice(10, 12));\n const date = Number(value.slice(12, 14));\n const d = new Date(year, month - 1, date);\n const isSameDate = d.getFullYear() === year && d.getMonth() + 1 === month && d.getDate() === date;\n\n if (!isSameDate) return false;\n\n // 将身份证号码前面的17位数分别乘以不同的系数；\n // 从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2\n // 将这17位数字和系数相乘的结果相加；\n // 用加出来和除以11，看余数是多少；\n // 余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字；\n // 其分别对应的最后一位身份证的号码为1－0－X－9－8－7－6－5－4－3－2\n // 通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。\n const coefficientList = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];\n const residueList = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];\n let sum = 0;\n\n for (let start = 0; start < 17; start++) {\n sum += Number(value.slice(start, start + 1)) coefficientList[start];\n }\n\n return residueList[sum % 11] === value.slice(-1);\n}\n\n// url\nconst URL_RE = /^https?:\\/\\//i;\n/*\n 判断字符串是否为 url 格式，仅支持 http 协议，支持域名或者 ipV4\n * @param {string} value\n * @returns {boolean}\n /\nexport function isURL(value: string): boolean {\n return URL_RE.test(value);\n}\n\n// ipv4\nconst IPV4_RE = /^(?:(?:\\d\|[1-9]\\d\|1\\d\\d\|2[0-4]\\d\|25[0-5])\\.){3}(?:\\d\|[1-9]\\d\|1\\d\\d\|2[0-4]\\d\|25[0-5])$/;\n/\n 判断字符串是否为 IPV4 格式，不对 ip 真实性做验证\n * @param {string} value\n * @returns {boolean}\n /\nexport function isIPV4(value: string): boolean {\n return IPV4_RE.test(value);\n}\n\nconst INTEGER_RE = /^(-?[1-9]\\d\|0)$/;\n/*\n 判断字符串是否为整数（自然数），即 ...,-3,-2,-1,0,1,2,3,...\n * @param {string} value\n * @returns {boolean}\n /\nexport function isInteger(value: string): boolean {\n return INTEGER_RE.test(value);\n}\n\nconst FLOAT_RE = /^-?([1-9]\\d\|0)\\.\\d+$/;\n/*\n 判断字符串是否为浮点数，即必须有小数点的有理数\n * @param {string} value\n * @returns {boolean}\n /\nexport function isFloat(value: string): boolean {\n return FLOAT_RE.test(value);\n}\n\n/\n 判断字符串是否为正确数值，包括整数和浮点数\n * @param {string} value\n * @returns {boolean}\n /\nexport function isNumerical(value: string): boolean {\n return isInteger(value) \|\| isFloat(value);\n}\n\nconst DIGIT_RE = /^\\d+$/;\n/\n 判断字符串是否为数字，例如六位数字短信验证码（093031）\n * @param {string} value\n * @returns {boolean}\n */\nexport function isDigit(value: string): boolean {\n return DIGIT_RE.test(value);\n}\n"],"mappings":";;AAAA,IAAM,YAAY;;;;;;;;;;;AAYlB,SAAgB,aAAa,QAAwB;CACnD,OAAO,OAAO,QAAQ,WAAW,OAAO;;AAI1C,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;AAI7B,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;AAsB7B,IAAM,UACJ;;;;;;AAMF,SAAgB,OAAO,OAAwB;CAG7C,IAAI,CAFiB,QAAQ,KAAK,MAE7B,EAAc,OAAO;CAE1B,MAAM,OAAO,OAAO,MAAM,MAAM,GAAG,GAAG,CAAC;CACvC,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI,GAAG,CAAC;CACzC,MAAM,OAAO,OAAO,MAAM,MAAM,IAAI,GAAG,CAAC;CACxC,MAAM,IAAI,IAAI,KAAK,MAAM,QAAQ,GAAG,KAAK;CAGzC,IAAI,EAFe,EAAE,aAAa,KAAK,QAAQ,EAAE,UAAU,GAAG,MAAM,SAAS,EAAE,SAAS,KAAK,OAE5E,OAAO;CASxB,MAAM,kBAAkB;EAAC;EAAG;EAAG;EAAI;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAI;EAAG;EAAG;EAAG;EAAE;CAC7E,MAAM,cAAc;EAAC;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAI;CAC3E,IAAI,MAAM;CAEV,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,SAC9B,OAAO,OAAO,MAAM,MAAM,OAAO,QAAQ,EAAE,CAAC,GAAG,gBAAgB;CAGjE,OAAO,YAAY,MAAM,QAAQ,MAAM,MAAM,GAAG;;AAIlD,IAAM,SAAS;;;;;;AAMf,SAAgB,MAAM,OAAwB;CAC5C,OAAO,OAAO,KAAK,MAAM;;AAI3B,IAAM,UAAU;;;;;;AAMhB,SAAgB,OAAO,OAAwB;CAC7C,OAAO,QAAQ,KAAK,MAAM;;AAG5B,IAAM,aAAa;;;;;;AAMnB,SAAgB,UAAU,OAAwB;CAChD,OAAO,WAAW,KAAK,MAAM;;AAG/B,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;;;;;;AAQ7B,SAAgB,YAAY,OAAwB;CAClD,OAAO,UAAU,MAAM,IAAI,QAAQ,MAAM;;AAG3C,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM"}

package/dist/regexp.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"regexp.mjs","names":[],"sources":["../src/regexp.ts"],"sourcesContent":["const specialRE = /[.+?^=!:${}()\|[\\]/\\\\-]/g;\n\n/\n 编码处理正则表达式\n * @example\n * ```js\n * reEscape('/$')\n * // => '\\\\/\\\\$'\n * ```\n * @param {string} string\n * @returns {string}\n /\nexport function regexpEscape(string: string): string {\n return string.replace(specialRE, '\\\\$&');\n}\n\n// 邮箱\nconst EMAIL_RE = /^\\w+[-+.\\w]@([a-z\\d-]+\\.)+[a-z]{2,5}$/i;\n/*\n 判断字符串是否为邮箱格式，不对邮箱真实性做验证，如域名是否正确等\n * @param {string} value\n * @returns {boolean}\n /\nexport function isEmail(value: string): boolean {\n return EMAIL_RE.test(value);\n}\n\n// 手机号码\nconst PHONE_RE = /^1\\d{10}$/;\n/\n 判断字符串是否为宽松手机格式，即首位为 1 的 11 位数字都属于手机号\n * @param {string} value\n * @returns {boolean}\n /\nexport function isPhone(value: string): boolean {\n return PHONE_RE.test(value);\n}\n\n// 身份证号码\n// http://www.stats.gov.cn/tjsj/tjbz/xzqhdm/\n// [\"北京市\", \"天津市\", \"河北省\", \"山西省\", \"内蒙古自治区\",\n// \"辽宁省\", \"吉林省\", \"黑龙江省\",\n// \"上海市\", \"江苏省\", \"浙江省\", \"安徽省\", \"福建省\", \"江西省\", \"山东省\",\n// \"河南省\", \"湖北省\", \"湖南省\", \"广东省\", \"广西壮族自治区\", \"海南省\",\n// \"重庆市\", \"四川省\", \"贵州省\", \"云南省\", \"西藏自治区\",\n// \"陕西省\", \"甘肃省\", \"青海省\",\"宁夏回族自治区\", \"新疆维吾尔自治区\",\n// \"台湾省\",\n// \"香港特别行政区\", \"澳门特别行政区\"]\n// [\"11\", \"12\", \"13\", \"14\", \"15\",\n// \"21\", \"22\", \"23\",\n// \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\",\n// \"41\", \"42\", \"43\", \"44\", \"45\", \"46\",\n// \"50\", \"51\", \"52\", \"53\", \"54\",\n// \"61\", \"62\", \"63\", \"64\", \"65\",\n// \"71\",\n// \"81\", \"82\"]\n// 91 国外\nconst IDNO_RE =\n /^(1[1-5]\|2[1-3]\|3[1-7]\|4[1-6]\|5[0-4]\|6[1-5]\|7[1]\|8[1-2]\|9[1])\\d{4}(18\|19\|20)\\d{2}[01]\\d[0123]\\d{4}[\\dxX]$/;\n/\n 判断字符串是否为身份证号码格式\n * @param {string} value\n * @returns {boolean}\n /\nexport function isIDNo(value: string): boolean {\n const isSameFormat = IDNO_RE.test(value);\n\n if (!isSameFormat) return false;\n\n const year = Number(value.slice(6, 10));\n const month = Number(value.slice(10, 12));\n const date = Number(value.slice(12, 14));\n const d = new Date(year, month - 1, date);\n const isSameDate ~~=\n~~ d.getFullYear() === year ~~&&\n~~ d.getMonth() + 1 === month ~~&&\n~~ d.getDate() === date;\n\n if (!isSameDate) return false;\n\n // 将身份证号码前面的17位数分别乘以不同的系数；\n // 从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2\n // 将这17位数字和系数相乘的结果相加；\n // 用加出来和除以11，看余数是多少；\n // 余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字；\n // 其分别对应的最后一位身份证的号码为1－0－X－9－8－7－6－5－4－3－2\n // 通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。\n const coefficientList = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];\n const residueList = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];\n let sum = 0;\n\n for (let start = 0; start < 17; start++) {\n sum += Number(value.slice(start, start + 1)) coefficientList[start];\n }\n\n return residueList[sum % 11] === value.slice(-1);\n}\n\n// url\nconst URL_RE = /^https?:\\/\\//i;\n/*\n 判断字符串是否为 url 格式，仅支持 http 协议，支持域名或者 ipV4\n * @param {string} value\n * @returns {boolean}\n /\nexport function isURL(value: string): boolean {\n return URL_RE.test(value);\n}\n\n// ipv4\nconst IPV4_RE ~~=\n~~ /^(?:(?:\\d\|[1-9]\\d\|1\\d\\d\|2[0-4]\\d\|25[0-5])\\.){3}(?:\\d\|[1-9]\\d\|1\\d\\d\|2[0-4]\\d\|25[0-5])$/;\n/\n 判断字符串是否为 IPV4 格式，不对 ip 真实性做验证\n * @param {string} value\n * @returns {boolean}\n /\nexport function isIPV4(value: string): boolean {\n return IPV4_RE.test(value);\n}\n\nconst INTEGER_RE = /^(-?[1-9]\\d\|0)$/;\n/*\n 判断字符串是否为整数（自然数），即 ...,-3,-2,-1,0,1,2,3,...\n * @param {string} value\n * @returns {boolean}\n /\nexport function isInteger(value: string): boolean {\n return INTEGER_RE.test(value);\n}\n\nconst FLOAT_RE = /^-?([1-9]\\d\|0)\\.\\d+$/;\n/*\n 判断字符串是否为浮点数，即必须有小数点的有理数\n * @param {string} value\n * @returns {boolean}\n /\nexport function isFloat(value: string): boolean {\n return FLOAT_RE.test(value);\n}\n\n/\n 判断字符串是否为正确数值，包括整数和浮点数\n * @param {string} value\n * @returns {boolean}\n /\nexport function isNumerical(value: string): boolean {\n return isInteger(value) \|\| isFloat(value);\n}\n\nconst DIGIT_RE = /^\\d+$/;\n/\n 判断字符串是否为数字，例如六位数字短信验证码（093031）\n * @param {string} value\n * @returns {boolean}\n */\nexport function isDigit(value: string): boolean {\n return DIGIT_RE.test(value);\n}\n"],"mappings":";AAAA,IAAM,YAAY;;;;;;;;;;;AAYlB,SAAgB,aAAa,QAAwB;CACnD,OAAO,OAAO,QAAQ,WAAW,OAAO;;AAI1C,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;AAI7B,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;AAsB7B,IAAM,UACJ;;;;;;AAMF,SAAgB,OAAO,OAAwB;CAG7C,IAAI,CAFiB,QAAQ,KAAK,MAE7B,EAAc,OAAO;CAE1B,MAAM,OAAO,OAAO,MAAM,MAAM,GAAG,GAAG,CAAC;CACvC,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI,GAAG,CAAC;CACzC,MAAM,OAAO,OAAO,MAAM,MAAM,IAAI,GAAG,CAAC;CACxC,MAAM,IAAI,IAAI,KAAK,MAAM,QAAQ,GAAG,KAAK;~~CAMzC~~,IAAI,~~EAJF~~,EAAE,aAAa,KAAK,~~QACpB~~,EAAE,UAAU,GAAG,MAAM,~~SACrB~~,EAAE,SAAS,KAAK,~~OAED~~,OAAO;CASxB,MAAM,kBAAkB;EAAC;EAAG;EAAG;EAAI;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAI;EAAG;EAAG;EAAG;EAAE;CAC7E,MAAM,cAAc;EAAC;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAI;CAC3E,IAAI,MAAM;CAEV,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,SAC9B,OAAO,OAAO,MAAM,MAAM,OAAO,QAAQ,EAAE,CAAC,GAAG,gBAAgB;CAGjE,OAAO,YAAY,MAAM,QAAQ,MAAM,MAAM,GAAG;;AAIlD,IAAM,SAAS;;;;;;AAMf,SAAgB,MAAM,OAAwB;CAC5C,OAAO,OAAO,KAAK,MAAM;;AAI3B,IAAM,~~UACJ~~;;;;;;~~AAMF~~,SAAgB,OAAO,OAAwB;CAC7C,OAAO,QAAQ,KAAK,MAAM;;AAG5B,IAAM,aAAa;;;;;;AAMnB,SAAgB,UAAU,OAAwB;CAChD,OAAO,WAAW,KAAK,MAAM;;AAG/B,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;;;;;;AAQ7B,SAAgB,YAAY,OAAwB;CAClD,OAAO,UAAU,MAAM,IAAI,QAAQ,MAAM;;AAG3C,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM"}
1	+ {"version":3,"file":"regexp.mjs","names":[],"sources":["../src/regexp.ts"],"sourcesContent":["const specialRE = /[.+?^=!:${}()\|[\\]/\\\\-]/g;\n\n/\n 编码处理正则表达式\n * @example\n * ```js\n * reEscape('/$')\n * // => '\\\\/\\\\$'\n * ```\n * @param {string} string\n * @returns {string}\n /\nexport function regexpEscape(string: string): string {\n return string.replace(specialRE, '\\\\$&');\n}\n\n// 邮箱\nconst EMAIL_RE = /^\\w+[-+.\\w]@([a-z\\d-]+\\.)+[a-z]{2,5}$/i;\n/*\n 判断字符串是否为邮箱格式，不对邮箱真实性做验证，如域名是否正确等\n * @param {string} value\n * @returns {boolean}\n /\nexport function isEmail(value: string): boolean {\n return EMAIL_RE.test(value);\n}\n\n// 手机号码\nconst PHONE_RE = /^1\\d{10}$/;\n/\n 判断字符串是否为宽松手机格式，即首位为 1 的 11 位数字都属于手机号\n * @param {string} value\n * @returns {boolean}\n /\nexport function isPhone(value: string): boolean {\n return PHONE_RE.test(value);\n}\n\n// 身份证号码\n// http://www.stats.gov.cn/tjsj/tjbz/xzqhdm/\n// [\"北京市\", \"天津市\", \"河北省\", \"山西省\", \"内蒙古自治区\",\n// \"辽宁省\", \"吉林省\", \"黑龙江省\",\n// \"上海市\", \"江苏省\", \"浙江省\", \"安徽省\", \"福建省\", \"江西省\", \"山东省\",\n// \"河南省\", \"湖北省\", \"湖南省\", \"广东省\", \"广西壮族自治区\", \"海南省\",\n// \"重庆市\", \"四川省\", \"贵州省\", \"云南省\", \"西藏自治区\",\n// \"陕西省\", \"甘肃省\", \"青海省\",\"宁夏回族自治区\", \"新疆维吾尔自治区\",\n// \"台湾省\",\n// \"香港特别行政区\", \"澳门特别行政区\"]\n// [\"11\", \"12\", \"13\", \"14\", \"15\",\n// \"21\", \"22\", \"23\",\n// \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\",\n// \"41\", \"42\", \"43\", \"44\", \"45\", \"46\",\n// \"50\", \"51\", \"52\", \"53\", \"54\",\n// \"61\", \"62\", \"63\", \"64\", \"65\",\n// \"71\",\n// \"81\", \"82\"]\n// 91 国外\nconst IDNO_RE =\n /^(1[1-5]\|2[1-3]\|3[1-7]\|4[1-6]\|5[0-4]\|6[1-5]\|7[1]\|8[1-2]\|9[1])\\d{4}(18\|19\|20)\\d{2}[01]\\d[0123]\\d{4}[\\dxX]$/;\n/\n 判断字符串是否为身份证号码格式\n * @param {string} value\n * @returns {boolean}\n /\nexport function isIDNo(value: string): boolean {\n const isSameFormat = IDNO_RE.test(value);\n\n if (!isSameFormat) return false;\n\n const year = Number(value.slice(6, 10));\n const month = Number(value.slice(10, 12));\n const date = Number(value.slice(12, 14));\n const d = new Date(year, month - 1, date);\n const isSameDate = d.getFullYear() === year && d.getMonth() + 1 === month && d.getDate() === date;\n\n if (!isSameDate) return false;\n\n // 将身份证号码前面的17位数分别乘以不同的系数；\n // 从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2\n // 将这17位数字和系数相乘的结果相加；\n // 用加出来和除以11，看余数是多少；\n // 余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字；\n // 其分别对应的最后一位身份证的号码为1－0－X－9－8－7－6－5－4－3－2\n // 通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。\n const coefficientList = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];\n const residueList = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];\n let sum = 0;\n\n for (let start = 0; start < 17; start++) {\n sum += Number(value.slice(start, start + 1)) coefficientList[start];\n }\n\n return residueList[sum % 11] === value.slice(-1);\n}\n\n// url\nconst URL_RE = /^https?:\\/\\//i;\n/*\n 判断字符串是否为 url 格式，仅支持 http 协议，支持域名或者 ipV4\n * @param {string} value\n * @returns {boolean}\n /\nexport function isURL(value: string): boolean {\n return URL_RE.test(value);\n}\n\n// ipv4\nconst IPV4_RE = /^(?:(?:\\d\|[1-9]\\d\|1\\d\\d\|2[0-4]\\d\|25[0-5])\\.){3}(?:\\d\|[1-9]\\d\|1\\d\\d\|2[0-4]\\d\|25[0-5])$/;\n/\n 判断字符串是否为 IPV4 格式，不对 ip 真实性做验证\n * @param {string} value\n * @returns {boolean}\n /\nexport function isIPV4(value: string): boolean {\n return IPV4_RE.test(value);\n}\n\nconst INTEGER_RE = /^(-?[1-9]\\d\|0)$/;\n/*\n 判断字符串是否为整数（自然数），即 ...,-3,-2,-1,0,1,2,3,...\n * @param {string} value\n * @returns {boolean}\n /\nexport function isInteger(value: string): boolean {\n return INTEGER_RE.test(value);\n}\n\nconst FLOAT_RE = /^-?([1-9]\\d\|0)\\.\\d+$/;\n/*\n 判断字符串是否为浮点数，即必须有小数点的有理数\n * @param {string} value\n * @returns {boolean}\n /\nexport function isFloat(value: string): boolean {\n return FLOAT_RE.test(value);\n}\n\n/\n 判断字符串是否为正确数值，包括整数和浮点数\n * @param {string} value\n * @returns {boolean}\n /\nexport function isNumerical(value: string): boolean {\n return isInteger(value) \|\| isFloat(value);\n}\n\nconst DIGIT_RE = /^\\d+$/;\n/\n 判断字符串是否为数字，例如六位数字短信验证码（093031）\n * @param {string} value\n * @returns {boolean}\n */\nexport function isDigit(value: string): boolean {\n return DIGIT_RE.test(value);\n}\n"],"mappings":";AAAA,IAAM,YAAY;;;;;;;;;;;AAYlB,SAAgB,aAAa,QAAwB;CACnD,OAAO,OAAO,QAAQ,WAAW,OAAO;;AAI1C,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;AAI7B,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;AAsB7B,IAAM,UACJ;;;;;;AAMF,SAAgB,OAAO,OAAwB;CAG7C,IAAI,CAFiB,QAAQ,KAAK,MAE7B,EAAc,OAAO;CAE1B,MAAM,OAAO,OAAO,MAAM,MAAM,GAAG,GAAG,CAAC;CACvC,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI,GAAG,CAAC;CACzC,MAAM,OAAO,OAAO,MAAM,MAAM,IAAI,GAAG,CAAC;CACxC,MAAM,IAAI,IAAI,KAAK,MAAM,QAAQ,GAAG,KAAK;CAGzC,IAAI,EAFe,EAAE,aAAa,KAAK,QAAQ,EAAE,UAAU,GAAG,MAAM,SAAS,EAAE,SAAS,KAAK,OAE5E,OAAO;CASxB,MAAM,kBAAkB;EAAC;EAAG;EAAG;EAAI;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAG;EAAI;EAAG;EAAG;EAAG;EAAE;CAC7E,MAAM,cAAc;EAAC;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAI;CAC3E,IAAI,MAAM;CAEV,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,SAC9B,OAAO,OAAO,MAAM,MAAM,OAAO,QAAQ,EAAE,CAAC,GAAG,gBAAgB;CAGjE,OAAO,YAAY,MAAM,QAAQ,MAAM,MAAM,GAAG;;AAIlD,IAAM,SAAS;;;;;;AAMf,SAAgB,MAAM,OAAwB;CAC5C,OAAO,OAAO,KAAK,MAAM;;AAI3B,IAAM,UAAU;;;;;;AAMhB,SAAgB,OAAO,OAAwB;CAC7C,OAAO,QAAQ,KAAK,MAAM;;AAG5B,IAAM,aAAa;;;;;;AAMnB,SAAgB,UAAU,OAAwB;CAChD,OAAO,WAAW,KAAK,MAAM;;AAG/B,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM;;;;;;;AAQ7B,SAAgB,YAAY,OAAwB;CAClD,OAAO,UAAU,MAAM,IAAI,QAAQ,MAAM;;AAG3C,IAAM,WAAW;;;;;;AAMjB,SAAgB,QAAQ,OAAwB;CAC9C,OAAO,SAAS,KAAK,MAAM"}

package/dist/string2.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"string2.cjs","names":[],"sources":["../src/number.ts","../src/string.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport { STRING_DICT } from './string';\nimport { isNumber } from './type';\n\nexport type NumberFixedOptions = {\n /*\n 保留的小数位数\n * @default 0\n /\n decimals?: number;\n\n /\n 舍入方法，0 为四舍五入，1 为向上取整，-1 为向下取整\n * @default 0\n /\n round?: 0 \| 1 \| -1;\n};\n\n/\n 对数字进行精确小数位数处理并按规则舍入\n * @param number 需要处理的原始数值\n * @param options 可选配置参数\n * @returns 处理后的数值（number类型）\n * @example\n * // 四舍五入示例\n * numberFixed(3.1415, { decimals: 2 }); // 3.14\n * // 向上取整示例\n * numberFixed(3.1415, { decimals: 2, round: 1 }); // 3.15\n * // 向下取整示例\n * numberFixed(3.9999, { decimals: 1, round: -1 }); // 3.9\n /\nexport function numberFixed(number: number, options?: NumberFixedOptions) {\n const { decimals = 0, round = 0 } = options \|\| {};\n const scale = 10 * decimals;\n\n if (round === 1) {\n return Math.ceil(number * scale) / scale;\n }\n\n if (round === -1) {\n return Math.floor(number * scale) / scale;\n }\n\n return Math.round(number * scale) / scale;\n}\n\n/*\n 生成指定范围内的随机数\n * @param {number \| string} min - 随机数的最小值（包含，支持小数、字符串）\n * @param {number \| string} max - 随机数的最大值（包含，支持小数、字符串）\n * @returns {number} - 生成的随机数\n * @example\n * // 生成 1 到 10 之间的随机整数\n * randomNumber(1, 10); // 可能返回 7\n \n // 生成 0.1 到 2 之间的一位随机小数\n * randomNumber(0.1, 2); // 可能返回 0.7\n \n // 生成 0.10 到 2 之间的两位随机小数\n * randomNumber(\"0.10\", 2); // 可能返回 0.75\n /\nexport function randomNumber(\n min: number \| string,\n max: number \| string,\n): number {\n const minDecimals = numberDecimals(min);\n const maxDecimals = numberDecimals(max);\n const decimals = Math.max(minDecimals, maxDecimals);\n const scale = 10 * decimals;\n\n const minNum = Number(min);\n const maxNum = Number(max);\n const [minFinal, maxFinal] =\n minNum > maxNum ? [maxNum, minNum] : [minNum, maxNum];\n\n const scaledMin = minFinal * scale;\n const scaledMax = maxFinal * scale;\n\n return (\n Math.floor(Math.random() * (scaledMax - scaledMin + 1) + scaledMin) / scale\n );\n}\n\n/*\n 数字缩写选项\n /\nexport type NumberAbbrOptions = {\n /\n 进制基数，用于计算单位进阶（如 1000 表示千进制）\n * @default 1000\n /\n base?: number;\n\n /\n 数值保留的小数位数\n * @default 0\n /\n decimals?: number;\n};\n\n/\n 将数字转换为带单位缩写的字符串表示\n \n @param {number} number - 需要转换的原始数值\n * @param {Array<string>} units - 单位数组，按从小到大顺序排列（如['B','KB','MB']），不能为空\n * @param {NumberAbbrOptions} [options] - 可选配置参数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * numberAbbr(1500, ['', 'K', 'M'], { base: 1000 }); // \"1.5K\"\n * @example\n * // 自定义小数位\n * numberAbbr(123456, ['B','KB','MB'], { decimals: 1 }); // \"0.1MB\"\n * @example\n * // 处理不足基数的情况\n * numberAbbr(500, ['B','KB']); // \"500B\"\n /\nexport function numberAbbr(\n number: number,\n units: Array<string>,\n options?: NumberAbbrOptions,\n): string {\n const { base = 1000, decimals = 0 } = options \|\| {};\n const { length } = units;\n\n if (length === 0) throw new Error('数字单位组不能为空');\n\n let numberFinal = number;\n let step = 0;\n\n while (numberFinal >= base && step < length - 1) {\n numberFinal = numberFinal / base;\n step++;\n }\n\n const value = numberFixed(numberFinal, { decimals: decimals, round: -1 });\n const unit = units[step];\n\n return `${value}${unit}`;\n}\n\n/\n 将文件大小转换为带单位缩写的字符串表示\n \n @param {number} number - 需要转换的文件大小数值\n * @param {number} [decimals=0] - 数值保留的小数位数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * fileSizeAbbr(1024); // \"1KB\"\n * @example\n * // 自定义小数位\n * fileSizeAbbr(123456, 1); // \"0.1MB\"\n /\nexport function fileSizeAbbr(number: number, decimals = 0) {\n return numberAbbr(number, ['B', 'KB', 'MB', 'GB', 'TB'], {\n base: 1024,\n decimals: decimals,\n });\n}\n\n/\n 将十进制数转换为指定进制的字符串表示\n \n @param {number \| bigint} decimal - 需要转换的十进制数，可以是任意长度的数字或大整数\n * @param {string} [dict] - 用于表示进制的字符字典，默认为数字、小写字母和大写字母的组合（62 进制）\n * @returns {string} - 转换后的指定进制字符串\n * @throws {Error} - 如果字符字典的长度小于 2，将抛出错误\n * @example\n * // 默认 62 进制\n * numberConvert(123456789); // \"8M0kX\"\n * @example\n * // 自定义 16 进制\n * numberConvert(255, '0123456789ABCDEF'); // \"FF\"\n * @example\n * // 处理大整数\n * numberConvert(9007199254740991n); // \"2gosa7pa2GV\"\n /\nexport function numberConvert(decimal: number \| bigint, dict?: string): string {\n const dictFinal = dict \|\| STRING_DICT;\n\n if (dictFinal.length < 2) throw new Error('进制转换字典长度不能小于 2');\n\n let bigInt = BigInt(decimal);\n const symbol = bigInt < 0n ? '-' : '';\n bigInt = bigInt < 0n ? -bigInt : bigInt;\n const result: Array<string> = [];\n const { length } = dictFinal;\n const bigLength = BigInt(length);\n const calculate = (): void => {\n const y = Number(bigInt % bigLength);\n\n bigInt = bigInt / bigLength;\n result.unshift(dictFinal[y]);\n\n if (bigInt > 0) {\n calculate();\n }\n };\n\n calculate();\n\n return symbol + result.join('');\n}\n\n/\n 数字格式化配置选项\n /\nexport type NumberFormatOptions = {\n /\n 分隔符字符，用于数字分隔\n * @default ','\n * @example 使用 '_' 分隔符时，123456 会格式化为 '123_456'\n /\n separator?: string;\n\n /\n 分隔步长，即每隔多少位添加分隔符\n * @default 3\n * @example 步长为 2 时，123456 会格式化为 '12,34,56'\n /\n step?: number;\n};\n\n/\n 数字格式化\n * @param [number] {number} 数字\n * @param options {NumberFormatOptions} 格式化配置\n * @returns {string} 分割后的字符串\n * @example\n * // 使用默认分隔符和步长\n * numberFormat(123456.789); // => \"123,456.789\"\n * // 自定义分隔符\n * numberFormat(123456.789, '_'); // => \"123_456.789\"\n * // 自定义步长\n * numberFormat(123456.789, 2); // => \"12,34,56.789\"\n * // 使用对象配置\n * numberFormat(123456.789, { separator: '.', step: 4 }); // => \"12.3456.789\"\n /\nexport function numberFormat(\n number: number \| string,\n options: NumberFormatOptions,\n): string;\nexport function numberFormat(\n number: number \| string,\n separator: string,\n): string;\nexport function numberFormat(number: number \| string, step: number): string;\nexport function numberFormat(number: number \| string): string;\nexport function numberFormat(\n number: number \| string,\n options?: NumberFormatOptions \| string \| number,\n) {\n let optionsFinal: Required<NumberFormatOptions> = {\n separator: ',',\n step: 3,\n };\n\n if (typeof options === 'string') {\n optionsFinal.separator = options;\n } else if (typeof options === 'number') {\n optionsFinal.step = options;\n } else {\n optionsFinal = objectDefaults(\n options \|\| {},\n optionsFinal,\n ) as Required<NumberFormatOptions>;\n }\n\n const { separator, step } = optionsFinal;\n const arr = String(number).split('.');\n const re = new RegExp(`(\\\\d)(?=(\\\\d{${step}})+(?!\\\\d))`, 'g');\n const p1 = arr[0].replace(re, `$1${separator}`);\n\n return p1 + (arr[1] ? `.${arr[1]}` : '');\n}\n\n/\n 将数字限制在指定范围内。\n \n @param min - 最小值。\n * @param number - 要限制的数字。\n * @param max - 最大值。\n * @returns 限制后的数字。\n /\nexport function numberClamp(min: number, number: number, max: number) {\n return Math.min(Math.max(number, min), max);\n}\n\n/\n 为数字添加单位\n * @param number - 需要处理的数字，可以是数字类型或字符串类型\n * @param unit - 要添加的单位，默认为空字符串\n * @returns 如果输入是数字或纯数字字符串，则返回带单位的字符串；否则返回原值\n /\nexport function numberUnit(number: string \| number, unit = '') {\n if (isNumber(number)) return `${number}${unit}`;\n if (/^-?[\\d.]+$/.test(number)) return `${number}${unit}`;\n return number;\n}\n\n/\n 获取数字的小数位数\n * @param num - 需要计算小数位数的数字或数字字符串\n * @returns 返回数字的小数位数，如果是整数则返回0\n * @example\n * // 基本用法\n * numberDecimals(3.1415); // 4\n * numberDecimals(\"3.1415\"); // 4\n * numberDecimals(100); // 0\n * numberDecimals(\"100\"); // 0\n * // 科学计数法\n * numberDecimals(\"1.23e-4\"); // 6\n /\nexport function numberDecimals(num: number \| string) {\n const numStr = String(num);\n const matches = numStr.match(/(?:\\.(\\d+))?(?:e-(\\d+))?$/i);\n if (!matches) return 0;\n return (matches[1] \|\| '').length + Number.parseInt(matches[2] \|\| '0', 10);\n}\n","import { randomNumber } from './number';\nimport { isFunction, isNullish, isObject, isUndefined } from './type';\n\n/* 阿拉伯数字字符集合 /\nexport const STRING_ARABIC_NUMERALS = '0123456789';\n/* 十六进制字符集合 /\nexport const STRING_HEXADECIMALS = '0123456789abcdef';\n/* 小写字母字符集合 /\nexport const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';\n/* 大写字母字符集合 /\nexport const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\n/* 随机字符串字典，包含数字、大写字母和小写字母 /\nexport const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;\n\n/\n 将字符串转换为驼峰格式\n * @param {string} string - 要转换的字符串\n * @param {boolean} [bigger] - 是否大写第一个字母，默认为 false\n * @returns {string} - 转换后的驼峰格式字符串\n /\nexport function stringCamelCase(string: string, bigger?: boolean): string {\n const string2 = string.replace(/[\\s_-](.)/g, (_, char) =>\n (char as string).toUpperCase(),\n );\n return bigger\n ? string2.slice(0, 1).toUpperCase() + string2.slice(1)\n : string2;\n}\n\n/\n 将字符串转换为连字格式\n * @param {string} string - 要转换的字符串\n * @param {string} [separator] - 分隔符，默认是 \"-\"（短横线）\n * @returns {string} - 转换后的连字格式字符串\n /\nexport function stringKebabCase(string: string, separator = '-'): string {\n return string.replace(\n /[A-Z]/g,\n (origin) => `${separator}${origin.toLowerCase()}`,\n );\n}\n\n/\n 生成随机字符串\n * @param {number} length - 生成的随机字符串长度\n * @param {string} [dict] - 用于生成随机字符串的字符字典，默认为数字、小写字母和大写字母的组合\n * @returns {string} - 生成的随机字符串\n * @example\n * randomString(10); // 生成一个长度为 10 的随机字符串\n * randomString(8, 'ABCDEF'); // 生成一个长度为 8 的随机字符串，仅包含字符 'ABCDEF'\n /\nexport function randomString(length: number, dict?: string): string {\n const dictFinal = dict \|\| STRING_DICT;\n const dictLength = dictFinal.length;\n\n let result = '';\n\n for (let i = 0; i < length; i++) {\n result += dictFinal.charAt(randomNumber(0, dictLength - 1));\n }\n\n return result;\n}\n\n/\n 简单的模板引擎，类似于 Python 的 `.format()` 方法\n * 支持通过索引或对象/名称的方式传递变量\n * 当使用对象/名称方式时，可以传递一个回退值作为第三个参数\n \n @category 字符串\n * @example\n * ```\n * // 索引方式\n * const result = stringFormat(\n * '你好 {0}！我的名字是 {1}。',\n * '张三',\n * '李四'\n * ); // 你好张三！我的名字是李四。\n * ```\n \n @example\n * ```\n * // 对象方式\n * const result = stringFormat(\n * '{greet}！我的名字是 {name}。',\n * { greet: '你好', name: '王五' }\n * ); // 你好！我的名字是王五。\n * ```\n \n @example\n * ```\n * // 带回退值的对象方式\n * const result = stringFormat(\n * '{greet}！我的名字是 {name}。',\n * { greet: '你好' }, // name 未传递，因此会使用回退值\n * '未知'\n * ); // 你好！我的名字是未知。\n * ```\n /\nexport function stringFormat(\n str: string,\n object: Record<string \| number, unknown>,\n fallback?: string \| ((key: string) => string),\n): string;\nexport function stringFormat(\n str: string,\n ...args: (string \| number \| bigint \| undefined \| null)[]\n): string;\nexport function stringFormat(str: string, ...args: unknown[]): string {\n const [firstArg, fallback] = args;\n\n if (isObject(firstArg) \|\| isUndefined(firstArg)) {\n const vars = firstArg \|\| {};\n return str.replace(\n /\\{(\\w+)\\}/g,\n (_, key) =>\n vars[key] ?? (isFunction(fallback) ? fallback(key) : fallback) ?? key,\n );\n }\n\n return str.replace(/\\{(\\d+)\\}/g, (_, key) => {\n const index = Number(key);\n if (Number.isNaN(index)) return key;\n return args[index];\n });\n}\n\n/\n 生成符合 [RFC 4122](https://www.ietf.org/rfc/rfc4122.txt) 版本 4 的 UUID 字符串\n * @returns {string} - 生成的 UUID 字符串\n * @example\n * const uuid = randomUUID4();\n * console.log(uuid); // 输出类似 '123e4567-e89b-12d3-a456-426614174000' 的 UUID 字符串\n /\nexport function randomUUID4(): string {\n const template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';\n let result = '';\n\n for (let i = 0; i < template.length; i++) {\n const t = template[i];\n\n if (t === '-' \|\| t === '4') {\n result += t;\n continue;\n }\n\n if (t === 'y') {\n result += randomString(1, '89ab');\n continue;\n }\n\n result += randomString(1, STRING_HEXADECIMALS);\n }\n\n return result;\n}\n\n/\n 将值转换为字符串，若值为 null 或 undefined 则返回空字符串\n * @param {unknown} value - 需要转换的值\n * @returns {string} 转换后的字符串结果\n */\nexport function stringify(value: unknown) {\n return isNullish(value) ? '' : String(value);\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"string2.cjs","names":[],"sources":["../src/number.ts","../src/string.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport { STRING_DICT } from './string';\nimport { isNumber } from './type';\n\nexport type NumberFixedOptions = {\n /*\n 保留的小数位数\n * @default 0\n /\n decimals?: number;\n\n /\n 舍入方法，0 为四舍五入，1 为向上取整，-1 为向下取整\n * @default 0\n /\n round?: 0 \| 1 \| -1;\n};\n\n/\n 对数字进行精确小数位数处理并按规则舍入\n * @param number 需要处理的原始数值\n * @param options 可选配置参数\n * @returns 处理后的数值（number类型）\n * @example\n * // 四舍五入示例\n * numberFixed(3.1415, { decimals: 2 }); // 3.14\n * // 向上取整示例\n * numberFixed(3.1415, { decimals: 2, round: 1 }); // 3.15\n * // 向下取整示例\n * numberFixed(3.9999, { decimals: 1, round: -1 }); // 3.9\n /\nexport function numberFixed(number: number, options?: NumberFixedOptions) {\n const { decimals = 0, round = 0 } = options \|\| {};\n const scale = 10 * decimals;\n\n if (round === 1) {\n return Math.ceil(number * scale) / scale;\n }\n\n if (round === -1) {\n return Math.floor(number * scale) / scale;\n }\n\n return Math.round(number * scale) / scale;\n}\n\n/*\n 生成指定范围内的随机数\n * @param {number \| string} min - 随机数的最小值（包含，支持小数、字符串）\n * @param {number \| string} max - 随机数的最大值（包含，支持小数、字符串）\n * @returns {number} - 生成的随机数\n * @example\n * // 生成 1 到 10 之间的随机整数\n * randomNumber(1, 10); // 可能返回 7\n \n // 生成 0.1 到 2 之间的一位随机小数\n * randomNumber(0.1, 2); // 可能返回 0.7\n \n // 生成 0.10 到 2 之间的两位随机小数\n * randomNumber(\"0.10\", 2); // 可能返回 0.75\n /\nexport function randomNumber(min: number \| string, max: number \| string): number {\n const minDecimals = numberDecimals(min);\n const maxDecimals = numberDecimals(max);\n const decimals = Math.max(minDecimals, maxDecimals);\n const scale = 10 * decimals;\n\n const minNum = Number(min);\n const maxNum = Number(max);\n const [minFinal, maxFinal] = minNum > maxNum ? [maxNum, minNum] : [minNum, maxNum];\n\n const scaledMin = minFinal * scale;\n const scaledMax = maxFinal * scale;\n\n return Math.floor(Math.random() * (scaledMax - scaledMin + 1) + scaledMin) / scale;\n}\n\n/*\n 数字缩写选项\n /\nexport type NumberAbbrOptions = {\n /\n 进制基数，用于计算单位进阶（如 1000 表示千进制）\n * @default 1000\n /\n base?: number;\n\n /\n 数值保留的小数位数\n * @default 0\n /\n decimals?: number;\n};\n\n/\n 将数字转换为带单位缩写的字符串表示\n \n @param {number} number - 需要转换的原始数值\n * @param {Array<string>} units - 单位数组，按从小到大顺序排列（如['B','KB','MB']），不能为空\n * @param {NumberAbbrOptions} [options] - 可选配置参数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * numberAbbr(1500, ['', 'K', 'M'], { base: 1000 }); // \"1.5K\"\n * @example\n * // 自定义小数位\n * numberAbbr(123456, ['B','KB','MB'], { decimals: 1 }); // \"0.1MB\"\n * @example\n * // 处理不足基数的情况\n * numberAbbr(500, ['B','KB']); // \"500B\"\n /\nexport function numberAbbr(number: number, units: Array<string>, options?: NumberAbbrOptions): string {\n const { base = 1000, decimals = 0 } = options \|\| {};\n const { length } = units;\n\n if (length === 0) throw new Error('数字单位组不能为空');\n\n let numberFinal = number;\n let step = 0;\n\n while (numberFinal >= base && step < length - 1) {\n numberFinal = numberFinal / base;\n step++;\n }\n\n const value = numberFixed(numberFinal, { decimals: decimals, round: -1 });\n const unit = units[step];\n\n return `${value}${unit}`;\n}\n\n/\n 将文件大小转换为带单位缩写的字符串表示\n \n @param {number} number - 需要转换的文件大小数值\n * @param {number} [decimals=0] - 数值保留的小数位数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * fileSizeAbbr(1024); // \"1KB\"\n * @example\n * // 自定义小数位\n * fileSizeAbbr(123456, 1); // \"0.1MB\"\n /\nexport function fileSizeAbbr(number: number, decimals = 0) {\n return numberAbbr(number, ['B', 'KB', 'MB', 'GB', 'TB'], {\n base: 1024,\n decimals: decimals,\n });\n}\n\n/\n 将十进制数转换为指定进制的字符串表示\n \n @param {number \| bigint} decimal - 需要转换的十进制数，可以是任意长度的数字或大整数\n * @param {string} [dict] - 用于表示进制的字符字典，默认为数字、小写字母和大写字母的组合（62 进制）\n * @returns {string} - 转换后的指定进制字符串\n * @throws {Error} - 如果字符字典的长度小于 2，将抛出错误\n * @example\n * // 默认 62 进制\n * numberConvert(123456789); // \"8M0kX\"\n * @example\n * // 自定义 16 进制\n * numberConvert(255, '0123456789ABCDEF'); // \"FF\"\n * @example\n * // 处理大整数\n * numberConvert(9007199254740991n); // \"2gosa7pa2GV\"\n /\nexport function numberConvert(decimal: number \| bigint, dict?: string): string {\n const dictFinal = dict \|\| STRING_DICT;\n\n if (dictFinal.length < 2) throw new Error('进制转换字典长度不能小于 2');\n\n let bigInt = BigInt(decimal);\n const symbol = bigInt < 0n ? '-' : '';\n bigInt = bigInt < 0n ? -bigInt : bigInt;\n const result: Array<string> = [];\n const { length } = dictFinal;\n const bigLength = BigInt(length);\n const calculate = (): void => {\n const y = Number(bigInt % bigLength);\n\n bigInt = bigInt / bigLength;\n result.unshift(dictFinal[y]);\n\n if (bigInt > 0) {\n calculate();\n }\n };\n\n calculate();\n\n return symbol + result.join('');\n}\n\n/\n 数字格式化配置选项\n /\nexport type NumberFormatOptions = {\n /\n 分隔符字符，用于数字分隔\n * @default ','\n * @example 使用 '_' 分隔符时，123456 会格式化为 '123_456'\n /\n separator?: string;\n\n /\n 分隔步长，即每隔多少位添加分隔符\n * @default 3\n * @example 步长为 2 时，123456 会格式化为 '12,34,56'\n /\n step?: number;\n};\n\n/\n 数字格式化\n * @param [number] {number} 数字\n * @param options {NumberFormatOptions} 格式化配置\n * @returns {string} 分割后的字符串\n * @example\n * // 使用默认分隔符和步长\n * numberFormat(123456.789); // => \"123,456.789\"\n * // 自定义分隔符\n * numberFormat(123456.789, '_'); // => \"123_456.789\"\n * // 自定义步长\n * numberFormat(123456.789, 2); // => \"12,34,56.789\"\n * // 使用对象配置\n * numberFormat(123456.789, { separator: '.', step: 4 }); // => \"12.3456.789\"\n /\nexport function numberFormat(number: number \| string, options: NumberFormatOptions): string;\nexport function numberFormat(number: number \| string, separator: string): string;\nexport function numberFormat(number: number \| string, step: number): string;\nexport function numberFormat(number: number \| string): string;\nexport function numberFormat(number: number \| string, options?: NumberFormatOptions \| string \| number) {\n let optionsFinal: Required<NumberFormatOptions> = {\n separator: ',',\n step: 3,\n };\n\n if (typeof options === 'string') {\n optionsFinal.separator = options;\n } else if (typeof options === 'number') {\n optionsFinal.step = options;\n } else {\n optionsFinal = objectDefaults(options \|\| {}, optionsFinal) as Required<NumberFormatOptions>;\n }\n\n const { separator, step } = optionsFinal;\n const arr = String(number).split('.');\n const re = new RegExp(`(\\\\d)(?=(\\\\d{${step}})+(?!\\\\d))`, 'g');\n const p1 = arr[0].replace(re, `$1${separator}`);\n\n return p1 + (arr[1] ? `.${arr[1]}` : '');\n}\n\n/\n 将数字限制在指定范围内。\n \n @param min - 最小值。\n * @param number - 要限制的数字。\n * @param max - 最大值。\n * @returns 限制后的数字。\n /\nexport function numberClamp(min: number, number: number, max: number) {\n return Math.min(Math.max(number, min), max);\n}\n\n/\n 为数字添加单位\n * @param number - 需要处理的数字，可以是数字类型或字符串类型\n * @param unit - 要添加的单位，默认为空字符串\n * @returns 如果输入是数字或纯数字字符串，则返回带单位的字符串；否则返回原值\n /\nexport function numberUnit(number: string \| number, unit = '') {\n if (isNumber(number)) return `${number}${unit}`;\n if (/^-?[\\d.]+$/.test(number)) return `${number}${unit}`;\n return number;\n}\n\n/\n 获取数字的小数位数\n * @param num - 需要计算小数位数的数字或数字字符串\n * @returns 返回数字的小数位数，如果是整数则返回0\n * @example\n * // 基本用法\n * numberDecimals(3.1415); // 4\n * numberDecimals(\"3.1415\"); // 4\n * numberDecimals(100); // 0\n * numberDecimals(\"100\"); // 0\n * // 科学计数法\n * numberDecimals(\"1.23e-4\"); // 6\n /\nexport function numberDecimals(num: number \| string) {\n const numStr = String(num);\n const matches = numStr.match(/(?:\\.(\\d+))?(?:e-(\\d+))?$/i);\n if (!matches) return 0;\n return (matches[1] \|\| '').length + Number.parseInt(matches[2] \|\| '0', 10);\n}\n","import { randomNumber } from './number';\nimport { isFunction, isNullish, isObject, isUndefined } from './type';\n\n/* 阿拉伯数字字符集合 /\nexport const STRING_ARABIC_NUMERALS = '0123456789';\n/* 十六进制字符集合 /\nexport const STRING_HEXADECIMALS = '0123456789abcdef';\n/* 小写字母字符集合 /\nexport const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';\n/* 大写字母字符集合 /\nexport const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\n/* 随机字符串字典，包含数字、大写字母和小写字母 /\nexport const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;\n\n/\n 将字符串转换为驼峰格式\n * @param {string} string - 要转换的字符串\n * @param {boolean} [bigger] - 是否大写第一个字母，默认为 false\n * @returns {string} - 转换后的驼峰格式字符串\n /\nexport function stringCamelCase(string: string, bigger?: boolean): string {\n const string2 = string.replace(/[\\s_-](.)/g, (_, char) => (char as string).toUpperCase());\n return bigger ? string2.slice(0, 1).toUpperCase() + string2.slice(1) : string2;\n}\n\n/\n 将字符串转换为连字格式\n * @param {string} string - 要转换的字符串\n * @param {string} [separator] - 分隔符，默认是 \"-\"（短横线）\n * @returns {string} - 转换后的连字格式字符串\n /\nexport function stringKebabCase(string: string, separator = '-'): string {\n return string.replace(/[A-Z]/g, (origin) => `${separator}${origin.toLowerCase()}`);\n}\n\n/\n 生成随机字符串\n * @param {number} length - 生成的随机字符串长度\n * @param {string} [dict] - 用于生成随机字符串的字符字典，默认为数字、小写字母和大写字母的组合\n * @returns {string} - 生成的随机字符串\n * @example\n * randomString(10); // 生成一个长度为 10 的随机字符串\n * randomString(8, 'ABCDEF'); // 生成一个长度为 8 的随机字符串，仅包含字符 'ABCDEF'\n /\nexport function randomString(length: number, dict?: string): string {\n const dictFinal = dict \|\| STRING_DICT;\n const dictLength = dictFinal.length;\n\n let result = '';\n\n for (let i = 0; i < length; i++) {\n result += dictFinal.charAt(randomNumber(0, dictLength - 1));\n }\n\n return result;\n}\n\n/\n 简单的模板引擎，类似于 Python 的 `.format()` 方法\n * 支持通过索引或对象/名称的方式传递变量\n * 当使用对象/名称方式时，可以传递一个回退值作为第三个参数\n \n @category 字符串\n * @example\n * ```\n * // 索引方式\n * const result = stringFormat(\n * '你好 {0}！我的名字是 {1}。',\n * '张三',\n * '李四'\n * ); // 你好张三！我的名字是李四。\n * ```\n \n @example\n * ```\n * // 对象方式\n * const result = stringFormat(\n * '{greet}！我的名字是 {name}。',\n * { greet: '你好', name: '王五' }\n * ); // 你好！我的名字是王五。\n * ```\n \n @example\n * ```\n * // 带回退值的对象方式\n * const result = stringFormat(\n * '{greet}！我的名字是 {name}。',\n * { greet: '你好' }, // name 未传递，因此会使用回退值\n * '未知'\n * ); // 你好！我的名字是未知。\n * ```\n /\nexport function stringFormat(\n str: string,\n object: Record<string \| number, unknown>,\n fallback?: string \| ((key: string) => string),\n): string;\nexport function stringFormat(str: string, ...args: (string \| number \| bigint \| undefined \| null)[]): string;\nexport function stringFormat(str: string, ...args: unknown[]): string {\n const [firstArg, fallback] = args;\n\n if (isObject(firstArg) \|\| isUndefined(firstArg)) {\n const vars = firstArg \|\| {};\n return str.replace(/\\{(\\w+)\\}/g, (_, key) => vars[key] ?? (isFunction(fallback) ? fallback(key) : fallback) ?? key);\n }\n\n return str.replace(/\\{(\\d+)\\}/g, (_, key) => {\n const index = Number(key);\n if (Number.isNaN(index)) return key;\n return args[index];\n });\n}\n\n/\n 生成符合 [RFC 4122](https://www.ietf.org/rfc/rfc4122.txt) 版本 4 的 UUID 字符串\n * @returns {string} - 生成的 UUID 字符串\n * @example\n * const uuid = randomUUID4();\n * console.log(uuid); // 输出类似 '123e4567-e89b-12d3-a456-426614174000' 的 UUID 字符串\n /\nexport function randomUUID4(): string {\n const template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';\n let result = '';\n\n for (let i = 0; i < template.length; i++) {\n const t = template[i];\n\n if (t === '-' \|\| t === '4') {\n result += t;\n continue;\n }\n\n if (t === 'y') {\n result += randomString(1, '89ab');\n continue;\n }\n\n result += randomString(1, STRING_HEXADECIMALS);\n }\n\n return result;\n}\n\n/\n 将值转换为字符串，若值为 null 或 undefined 则返回空字符串\n * @param {unknown} value - 需要转换的值\n * @returns {string} 转换后的字符串结果\n */\nexport function stringify(value: unknown) {\n return isNullish(value) ? '' : String(value);\n}\n"],"mappings":"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"}

package/dist/string2.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"string2.mjs","names":[],"sources":["../src/number.ts","../src/string.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport { STRING_DICT } from './string';\nimport { isNumber } from './type';\n\nexport type NumberFixedOptions = {\n /*\n 保留的小数位数\n * @default 0\n /\n decimals?: number;\n\n /\n 舍入方法，0 为四舍五入，1 为向上取整，-1 为向下取整\n * @default 0\n /\n round?: 0 \| 1 \| -1;\n};\n\n/\n 对数字进行精确小数位数处理并按规则舍入\n * @param number 需要处理的原始数值\n * @param options 可选配置参数\n * @returns 处理后的数值（number类型）\n * @example\n * // 四舍五入示例\n * numberFixed(3.1415, { decimals: 2 }); // 3.14\n * // 向上取整示例\n * numberFixed(3.1415, { decimals: 2, round: 1 }); // 3.15\n * // 向下取整示例\n * numberFixed(3.9999, { decimals: 1, round: -1 }); // 3.9\n /\nexport function numberFixed(number: number, options?: NumberFixedOptions) {\n const { decimals = 0, round = 0 } = options \|\| {};\n const scale = 10 * decimals;\n\n if (round === 1) {\n return Math.ceil(number * scale) / scale;\n }\n\n if (round === -1) {\n return Math.floor(number * scale) / scale;\n }\n\n return Math.round(number * scale) / scale;\n}\n\n/*\n 生成指定范围内的随机数\n * @param {number \| string} min - 随机数的最小值（包含，支持小数、字符串）\n * @param {number \| string} max - 随机数的最大值（包含，支持小数、字符串）\n * @returns {number} - 生成的随机数\n * @example\n * // 生成 1 到 10 之间的随机整数\n * randomNumber(1, 10); // 可能返回 7\n \n // 生成 0.1 到 2 之间的一位随机小数\n * randomNumber(0.1, 2); // 可能返回 0.7\n \n // 生成 0.10 到 2 之间的两位随机小数\n * randomNumber(\"0.10\", 2); // 可能返回 0.75\n /\nexport function randomNumber(\n min: number \| string,\n max: number \| string,\n): number {\n const minDecimals = numberDecimals(min);\n const maxDecimals = numberDecimals(max);\n const decimals = Math.max(minDecimals, maxDecimals);\n const scale = 10 * decimals;\n\n const minNum = Number(min);\n const maxNum = Number(max);\n const [minFinal, maxFinal] =\n minNum > maxNum ? [maxNum, minNum] : [minNum, maxNum];\n\n const scaledMin = minFinal * scale;\n const scaledMax = maxFinal * scale;\n\n return (\n Math.floor(Math.random() * (scaledMax - scaledMin + 1) + scaledMin) / scale\n );\n}\n\n/*\n 数字缩写选项\n /\nexport type NumberAbbrOptions = {\n /\n 进制基数，用于计算单位进阶（如 1000 表示千进制）\n * @default 1000\n /\n base?: number;\n\n /\n 数值保留的小数位数\n * @default 0\n /\n decimals?: number;\n};\n\n/\n 将数字转换为带单位缩写的字符串表示\n \n @param {number} number - 需要转换的原始数值\n * @param {Array<string>} units - 单位数组，按从小到大顺序排列（如['B','KB','MB']），不能为空\n * @param {NumberAbbrOptions} [options] - 可选配置参数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * numberAbbr(1500, ['', 'K', 'M'], { base: 1000 }); // \"1.5K\"\n * @example\n * // 自定义小数位\n * numberAbbr(123456, ['B','KB','MB'], { decimals: 1 }); // \"0.1MB\"\n * @example\n * // 处理不足基数的情况\n * numberAbbr(500, ['B','KB']); // \"500B\"\n /\nexport function numberAbbr(\n number: number,\n units: Array<string>,\n options?: NumberAbbrOptions,\n): string {\n const { base = 1000, decimals = 0 } = options \|\| {};\n const { length } = units;\n\n if (length === 0) throw new Error('数字单位组不能为空');\n\n let numberFinal = number;\n let step = 0;\n\n while (numberFinal >= base && step < length - 1) {\n numberFinal = numberFinal / base;\n step++;\n }\n\n const value = numberFixed(numberFinal, { decimals: decimals, round: -1 });\n const unit = units[step];\n\n return `${value}${unit}`;\n}\n\n/\n 将文件大小转换为带单位缩写的字符串表示\n \n @param {number} number - 需要转换的文件大小数值\n * @param {number} [decimals=0] - 数值保留的小数位数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * fileSizeAbbr(1024); // \"1KB\"\n * @example\n * // 自定义小数位\n * fileSizeAbbr(123456, 1); // \"0.1MB\"\n /\nexport function fileSizeAbbr(number: number, decimals = 0) {\n return numberAbbr(number, ['B', 'KB', 'MB', 'GB', 'TB'], {\n base: 1024,\n decimals: decimals,\n });\n}\n\n/\n 将十进制数转换为指定进制的字符串表示\n \n @param {number \| bigint} decimal - 需要转换的十进制数，可以是任意长度的数字或大整数\n * @param {string} [dict] - 用于表示进制的字符字典，默认为数字、小写字母和大写字母的组合（62 进制）\n * @returns {string} - 转换后的指定进制字符串\n * @throws {Error} - 如果字符字典的长度小于 2，将抛出错误\n * @example\n * // 默认 62 进制\n * numberConvert(123456789); // \"8M0kX\"\n * @example\n * // 自定义 16 进制\n * numberConvert(255, '0123456789ABCDEF'); // \"FF\"\n * @example\n * // 处理大整数\n * numberConvert(9007199254740991n); // \"2gosa7pa2GV\"\n /\nexport function numberConvert(decimal: number \| bigint, dict?: string): string {\n const dictFinal = dict \|\| STRING_DICT;\n\n if (dictFinal.length < 2) throw new Error('进制转换字典长度不能小于 2');\n\n let bigInt = BigInt(decimal);\n const symbol = bigInt < 0n ? '-' : '';\n bigInt = bigInt < 0n ? -bigInt : bigInt;\n const result: Array<string> = [];\n const { length } = dictFinal;\n const bigLength = BigInt(length);\n const calculate = (): void => {\n const y = Number(bigInt % bigLength);\n\n bigInt = bigInt / bigLength;\n result.unshift(dictFinal[y]);\n\n if (bigInt > 0) {\n calculate();\n }\n };\n\n calculate();\n\n return symbol + result.join('');\n}\n\n/\n 数字格式化配置选项\n /\nexport type NumberFormatOptions = {\n /\n 分隔符字符，用于数字分隔\n * @default ','\n * @example 使用 '_' 分隔符时，123456 会格式化为 '123_456'\n /\n separator?: string;\n\n /\n 分隔步长，即每隔多少位添加分隔符\n * @default 3\n * @example 步长为 2 时，123456 会格式化为 '12,34,56'\n /\n step?: number;\n};\n\n/\n 数字格式化\n * @param [number] {number} 数字\n * @param options {NumberFormatOptions} 格式化配置\n * @returns {string} 分割后的字符串\n * @example\n * // 使用默认分隔符和步长\n * numberFormat(123456.789); // => \"123,456.789\"\n * // 自定义分隔符\n * numberFormat(123456.789, '_'); // => \"123_456.789\"\n * // 自定义步长\n * numberFormat(123456.789, 2); // => \"12,34,56.789\"\n * // 使用对象配置\n * numberFormat(123456.789, { separator: '.', step: 4 }); // => \"12.3456.789\"\n /\nexport function numberFormat(\n number: number \| string,\n options: NumberFormatOptions,\n): string;\nexport function numberFormat(\n number: number \| string,\n separator: string,\n): string;\nexport function numberFormat(number: number \| string, step: number): string;\nexport function numberFormat(number: number \| string): string;\nexport function numberFormat(\n number: number \| string,\n options?: NumberFormatOptions \| string \| number,\n) {\n let optionsFinal: Required<NumberFormatOptions> = {\n separator: ',',\n step: 3,\n };\n\n if (typeof options === 'string') {\n optionsFinal.separator = options;\n } else if (typeof options === 'number') {\n optionsFinal.step = options;\n } else {\n optionsFinal = objectDefaults(\n options \|\| {},\n optionsFinal,\n ) as Required<NumberFormatOptions>;\n }\n\n const { separator, step } = optionsFinal;\n const arr = String(number).split('.');\n const re = new RegExp(`(\\\\d)(?=(\\\\d{${step}})+(?!\\\\d))`, 'g');\n const p1 = arr[0].replace(re, `$1${separator}`);\n\n return p1 + (arr[1] ? `.${arr[1]}` : '');\n}\n\n/\n 将数字限制在指定范围内。\n \n @param min - 最小值。\n * @param number - 要限制的数字。\n * @param max - 最大值。\n * @returns 限制后的数字。\n /\nexport function numberClamp(min: number, number: number, max: number) {\n return Math.min(Math.max(number, min), max);\n}\n\n/\n 为数字添加单位\n * @param number - 需要处理的数字，可以是数字类型或字符串类型\n * @param unit - 要添加的单位，默认为空字符串\n * @returns 如果输入是数字或纯数字字符串，则返回带单位的字符串；否则返回原值\n /\nexport function numberUnit(number: string \| number, unit = '') {\n if (isNumber(number)) return `${number}${unit}`;\n if (/^-?[\\d.]+$/.test(number)) return `${number}${unit}`;\n return number;\n}\n\n/\n 获取数字的小数位数\n * @param num - 需要计算小数位数的数字或数字字符串\n * @returns 返回数字的小数位数，如果是整数则返回0\n * @example\n * // 基本用法\n * numberDecimals(3.1415); // 4\n * numberDecimals(\"3.1415\"); // 4\n * numberDecimals(100); // 0\n * numberDecimals(\"100\"); // 0\n * // 科学计数法\n * numberDecimals(\"1.23e-4\"); // 6\n /\nexport function numberDecimals(num: number \| string) {\n const numStr = String(num);\n const matches = numStr.match(/(?:\\.(\\d+))?(?:e-(\\d+))?$/i);\n if (!matches) return 0;\n return (matches[1] \|\| '').length + Number.parseInt(matches[2] \|\| '0', 10);\n}\n","import { randomNumber } from './number';\nimport { isFunction, isNullish, isObject, isUndefined } from './type';\n\n/* 阿拉伯数字字符集合 /\nexport const STRING_ARABIC_NUMERALS = '0123456789';\n/* 十六进制字符集合 /\nexport const STRING_HEXADECIMALS = '0123456789abcdef';\n/* 小写字母字符集合 /\nexport const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';\n/* 大写字母字符集合 /\nexport const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\n/* 随机字符串字典，包含数字、大写字母和小写字母 /\nexport const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;\n\n/\n 将字符串转换为驼峰格式\n * @param {string} string - 要转换的字符串\n * @param {boolean} [bigger] - 是否大写第一个字母，默认为 false\n * @returns {string} - 转换后的驼峰格式字符串\n /\nexport function stringCamelCase(string: string, bigger?: boolean): string {\n const string2 = string.replace(/[\\s_-](.)/g, (_, char) =>\n (char as string).toUpperCase(),\n );\n return bigger\n ? string2.slice(0, 1).toUpperCase() + string2.slice(1)\n : string2;\n}\n\n/\n 将字符串转换为连字格式\n * @param {string} string - 要转换的字符串\n * @param {string} [separator] - 分隔符，默认是 \"-\"（短横线）\n * @returns {string} - 转换后的连字格式字符串\n /\nexport function stringKebabCase(string: string, separator = '-'): string {\n return string.replace(\n /[A-Z]/g,\n (origin) => `${separator}${origin.toLowerCase()}`,\n );\n}\n\n/\n 生成随机字符串\n * @param {number} length - 生成的随机字符串长度\n * @param {string} [dict] - 用于生成随机字符串的字符字典，默认为数字、小写字母和大写字母的组合\n * @returns {string} - 生成的随机字符串\n * @example\n * randomString(10); // 生成一个长度为 10 的随机字符串\n * randomString(8, 'ABCDEF'); // 生成一个长度为 8 的随机字符串，仅包含字符 'ABCDEF'\n /\nexport function randomString(length: number, dict?: string): string {\n const dictFinal = dict \|\| STRING_DICT;\n const dictLength = dictFinal.length;\n\n let result = '';\n\n for (let i = 0; i < length; i++) {\n result += dictFinal.charAt(randomNumber(0, dictLength - 1));\n }\n\n return result;\n}\n\n/\n 简单的模板引擎，类似于 Python 的 `.format()` 方法\n * 支持通过索引或对象/名称的方式传递变量\n * 当使用对象/名称方式时，可以传递一个回退值作为第三个参数\n \n @category 字符串\n * @example\n * ```\n * // 索引方式\n * const result = stringFormat(\n * '你好 {0}！我的名字是 {1}。',\n * '张三',\n * '李四'\n * ); // 你好张三！我的名字是李四。\n * ```\n \n @example\n * ```\n * // 对象方式\n * const result = stringFormat(\n * '{greet}！我的名字是 {name}。',\n * { greet: '你好', name: '王五' }\n * ); // 你好！我的名字是王五。\n * ```\n \n @example\n * ```\n * // 带回退值的对象方式\n * const result = stringFormat(\n * '{greet}！我的名字是 {name}。',\n * { greet: '你好' }, // name 未传递，因此会使用回退值\n * '未知'\n * ); // 你好！我的名字是未知。\n * ```\n /\nexport function stringFormat(\n str: string,\n object: Record<string \| number, unknown>,\n fallback?: string \| ((key: string) => string),\n): string;\nexport function stringFormat(\n str: string,\n ...args: (string \| number \| bigint \| undefined \| null)[]\n): string;\nexport function stringFormat(str: string, ...args: unknown[]): string {\n const [firstArg, fallback] = args;\n\n if (isObject(firstArg) \|\| isUndefined(firstArg)) {\n const vars = firstArg \|\| {};\n return str.replace(\n /\\{(\\w+)\\}/g,\n (_, key) =>\n vars[key] ?? (isFunction(fallback) ? fallback(key) : fallback) ?? key,\n );\n }\n\n return str.replace(/\\{(\\d+)\\}/g, (_, key) => {\n const index = Number(key);\n if (Number.isNaN(index)) return key;\n return args[index];\n });\n}\n\n/\n 生成符合 [RFC 4122](https://www.ietf.org/rfc/rfc4122.txt) 版本 4 的 UUID 字符串\n * @returns {string} - 生成的 UUID 字符串\n * @example\n * const uuid = randomUUID4();\n * console.log(uuid); // 输出类似 '123e4567-e89b-12d3-a456-426614174000' 的 UUID 字符串\n /\nexport function randomUUID4(): string {\n const template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';\n let result = '';\n\n for (let i = 0; i < template.length; i++) {\n const t = template[i];\n\n if (t === '-' \|\| t === '4') {\n result += t;\n continue;\n }\n\n if (t === 'y') {\n result += randomString(1, '89ab');\n continue;\n }\n\n result += randomString(1, STRING_HEXADECIMALS);\n }\n\n return result;\n}\n\n/\n 将值转换为字符串，若值为 null 或 undefined 则返回空字符串\n * @param {unknown} value - 需要转换的值\n * @returns {string} 转换后的字符串结果\n */\nexport function stringify(value: unknown) {\n return isNullish(value) ? '' : String(value);\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"string2.mjs","names":[],"sources":["../src/number.ts","../src/string.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport { STRING_DICT } from './string';\nimport { isNumber } from './type';\n\nexport type NumberFixedOptions = {\n /*\n 保留的小数位数\n * @default 0\n /\n decimals?: number;\n\n /\n 舍入方法，0 为四舍五入，1 为向上取整，-1 为向下取整\n * @default 0\n /\n round?: 0 \| 1 \| -1;\n};\n\n/\n 对数字进行精确小数位数处理并按规则舍入\n * @param number 需要处理的原始数值\n * @param options 可选配置参数\n * @returns 处理后的数值（number类型）\n * @example\n * // 四舍五入示例\n * numberFixed(3.1415, { decimals: 2 }); // 3.14\n * // 向上取整示例\n * numberFixed(3.1415, { decimals: 2, round: 1 }); // 3.15\n * // 向下取整示例\n * numberFixed(3.9999, { decimals: 1, round: -1 }); // 3.9\n /\nexport function numberFixed(number: number, options?: NumberFixedOptions) {\n const { decimals = 0, round = 0 } = options \|\| {};\n const scale = 10 * decimals;\n\n if (round === 1) {\n return Math.ceil(number * scale) / scale;\n }\n\n if (round === -1) {\n return Math.floor(number * scale) / scale;\n }\n\n return Math.round(number * scale) / scale;\n}\n\n/*\n 生成指定范围内的随机数\n * @param {number \| string} min - 随机数的最小值（包含，支持小数、字符串）\n * @param {number \| string} max - 随机数的最大值（包含，支持小数、字符串）\n * @returns {number} - 生成的随机数\n * @example\n * // 生成 1 到 10 之间的随机整数\n * randomNumber(1, 10); // 可能返回 7\n \n // 生成 0.1 到 2 之间的一位随机小数\n * randomNumber(0.1, 2); // 可能返回 0.7\n \n // 生成 0.10 到 2 之间的两位随机小数\n * randomNumber(\"0.10\", 2); // 可能返回 0.75\n /\nexport function randomNumber(min: number \| string, max: number \| string): number {\n const minDecimals = numberDecimals(min);\n const maxDecimals = numberDecimals(max);\n const decimals = Math.max(minDecimals, maxDecimals);\n const scale = 10 * decimals;\n\n const minNum = Number(min);\n const maxNum = Number(max);\n const [minFinal, maxFinal] = minNum > maxNum ? [maxNum, minNum] : [minNum, maxNum];\n\n const scaledMin = minFinal * scale;\n const scaledMax = maxFinal * scale;\n\n return Math.floor(Math.random() * (scaledMax - scaledMin + 1) + scaledMin) / scale;\n}\n\n/*\n 数字缩写选项\n /\nexport type NumberAbbrOptions = {\n /\n 进制基数，用于计算单位进阶（如 1000 表示千进制）\n * @default 1000\n /\n base?: number;\n\n /\n 数值保留的小数位数\n * @default 0\n /\n decimals?: number;\n};\n\n/\n 将数字转换为带单位缩写的字符串表示\n \n @param {number} number - 需要转换的原始数值\n * @param {Array<string>} units - 单位数组，按从小到大顺序排列（如['B','KB','MB']），不能为空\n * @param {NumberAbbrOptions} [options] - 可选配置参数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * numberAbbr(1500, ['', 'K', 'M'], { base: 1000 }); // \"1.5K\"\n * @example\n * // 自定义小数位\n * numberAbbr(123456, ['B','KB','MB'], { decimals: 1 }); // \"0.1MB\"\n * @example\n * // 处理不足基数的情况\n * numberAbbr(500, ['B','KB']); // \"500B\"\n /\nexport function numberAbbr(number: number, units: Array<string>, options?: NumberAbbrOptions): string {\n const { base = 1000, decimals = 0 } = options \|\| {};\n const { length } = units;\n\n if (length === 0) throw new Error('数字单位组不能为空');\n\n let numberFinal = number;\n let step = 0;\n\n while (numberFinal >= base && step < length - 1) {\n numberFinal = numberFinal / base;\n step++;\n }\n\n const value = numberFixed(numberFinal, { decimals: decimals, round: -1 });\n const unit = units[step];\n\n return `${value}${unit}`;\n}\n\n/\n 将文件大小转换为带单位缩写的字符串表示\n \n @param {number} number - 需要转换的文件大小数值\n * @param {number} [decimals=0] - 数值保留的小数位数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * fileSizeAbbr(1024); // \"1KB\"\n * @example\n * // 自定义小数位\n * fileSizeAbbr(123456, 1); // \"0.1MB\"\n /\nexport function fileSizeAbbr(number: number, decimals = 0) {\n return numberAbbr(number, ['B', 'KB', 'MB', 'GB', 'TB'], {\n base: 1024,\n decimals: decimals,\n });\n}\n\n/\n 将十进制数转换为指定进制的字符串表示\n \n @param {number \| bigint} decimal - 需要转换的十进制数，可以是任意长度的数字或大整数\n * @param {string} [dict] - 用于表示进制的字符字典，默认为数字、小写字母和大写字母的组合（62 进制）\n * @returns {string} - 转换后的指定进制字符串\n * @throws {Error} - 如果字符字典的长度小于 2，将抛出错误\n * @example\n * // 默认 62 进制\n * numberConvert(123456789); // \"8M0kX\"\n * @example\n * // 自定义 16 进制\n * numberConvert(255, '0123456789ABCDEF'); // \"FF\"\n * @example\n * // 处理大整数\n * numberConvert(9007199254740991n); // \"2gosa7pa2GV\"\n /\nexport function numberConvert(decimal: number \| bigint, dict?: string): string {\n const dictFinal = dict \|\| STRING_DICT;\n\n if (dictFinal.length < 2) throw new Error('进制转换字典长度不能小于 2');\n\n let bigInt = BigInt(decimal);\n const symbol = bigInt < 0n ? '-' : '';\n bigInt = bigInt < 0n ? -bigInt : bigInt;\n const result: Array<string> = [];\n const { length } = dictFinal;\n const bigLength = BigInt(length);\n const calculate = (): void => {\n const y = Number(bigInt % bigLength);\n\n bigInt = bigInt / bigLength;\n result.unshift(dictFinal[y]);\n\n if (bigInt > 0) {\n calculate();\n }\n };\n\n calculate();\n\n return symbol + result.join('');\n}\n\n/\n 数字格式化配置选项\n /\nexport type NumberFormatOptions = {\n /\n 分隔符字符，用于数字分隔\n * @default ','\n * @example 使用 '_' 分隔符时，123456 会格式化为 '123_456'\n /\n separator?: string;\n\n /\n 分隔步长，即每隔多少位添加分隔符\n * @default 3\n * @example 步长为 2 时，123456 会格式化为 '12,34,56'\n /\n step?: number;\n};\n\n/\n 数字格式化\n * @param [number] {number} 数字\n * @param options {NumberFormatOptions} 格式化配置\n * @returns {string} 分割后的字符串\n * @example\n * // 使用默认分隔符和步长\n * numberFormat(123456.789); // => \"123,456.789\"\n * // 自定义分隔符\n * numberFormat(123456.789, '_'); // => \"123_456.789\"\n * // 自定义步长\n * numberFormat(123456.789, 2); // => \"12,34,56.789\"\n * // 使用对象配置\n * numberFormat(123456.789, { separator: '.', step: 4 }); // => \"12.3456.789\"\n /\nexport function numberFormat(number: number \| string, options: NumberFormatOptions): string;\nexport function numberFormat(number: number \| string, separator: string): string;\nexport function numberFormat(number: number \| string, step: number): string;\nexport function numberFormat(number: number \| string): string;\nexport function numberFormat(number: number \| string, options?: NumberFormatOptions \| string \| number) {\n let optionsFinal: Required<NumberFormatOptions> = {\n separator: ',',\n step: 3,\n };\n\n if (typeof options === 'string') {\n optionsFinal.separator = options;\n } else if (typeof options === 'number') {\n optionsFinal.step = options;\n } else {\n optionsFinal = objectDefaults(options \|\| {}, optionsFinal) as Required<NumberFormatOptions>;\n }\n\n const { separator, step } = optionsFinal;\n const arr = String(number).split('.');\n const re = new RegExp(`(\\\\d)(?=(\\\\d{${step}})+(?!\\\\d))`, 'g');\n const p1 = arr[0].replace(re, `$1${separator}`);\n\n return p1 + (arr[1] ? `.${arr[1]}` : '');\n}\n\n/\n 将数字限制在指定范围内。\n \n @param min - 最小值。\n * @param number - 要限制的数字。\n * @param max - 最大值。\n * @returns 限制后的数字。\n /\nexport function numberClamp(min: number, number: number, max: number) {\n return Math.min(Math.max(number, min), max);\n}\n\n/\n 为数字添加单位\n * @param number - 需要处理的数字，可以是数字类型或字符串类型\n * @param unit - 要添加的单位，默认为空字符串\n * @returns 如果输入是数字或纯数字字符串，则返回带单位的字符串；否则返回原值\n /\nexport function numberUnit(number: string \| number, unit = '') {\n if (isNumber(number)) return `${number}${unit}`;\n if (/^-?[\\d.]+$/.test(number)) return `${number}${unit}`;\n return number;\n}\n\n/\n 获取数字的小数位数\n * @param num - 需要计算小数位数的数字或数字字符串\n * @returns 返回数字的小数位数，如果是整数则返回0\n * @example\n * // 基本用法\n * numberDecimals(3.1415); // 4\n * numberDecimals(\"3.1415\"); // 4\n * numberDecimals(100); // 0\n * numberDecimals(\"100\"); // 0\n * // 科学计数法\n * numberDecimals(\"1.23e-4\"); // 6\n /\nexport function numberDecimals(num: number \| string) {\n const numStr = String(num);\n const matches = numStr.match(/(?:\\.(\\d+))?(?:e-(\\d+))?$/i);\n if (!matches) return 0;\n return (matches[1] \|\| '').length + Number.parseInt(matches[2] \|\| '0', 10);\n}\n","import { randomNumber } from './number';\nimport { isFunction, isNullish, isObject, isUndefined } from './type';\n\n/* 阿拉伯数字字符集合 /\nexport const STRING_ARABIC_NUMERALS = '0123456789';\n/* 十六进制字符集合 /\nexport const STRING_HEXADECIMALS = '0123456789abcdef';\n/* 小写字母字符集合 /\nexport const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';\n/* 大写字母字符集合 /\nexport const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\n/* 随机字符串字典，包含数字、大写字母和小写字母 /\nexport const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;\n\n/\n 将字符串转换为驼峰格式\n * @param {string} string - 要转换的字符串\n * @param {boolean} [bigger] - 是否大写第一个字母，默认为 false\n * @returns {string} - 转换后的驼峰格式字符串\n /\nexport function stringCamelCase(string: string, bigger?: boolean): string {\n const string2 = string.replace(/[\\s_-](.)/g, (_, char) => (char as string).toUpperCase());\n return bigger ? string2.slice(0, 1).toUpperCase() + string2.slice(1) : string2;\n}\n\n/\n 将字符串转换为连字格式\n * @param {string} string - 要转换的字符串\n * @param {string} [separator] - 分隔符，默认是 \"-\"（短横线）\n * @returns {string} - 转换后的连字格式字符串\n /\nexport function stringKebabCase(string: string, separator = '-'): string {\n return string.replace(/[A-Z]/g, (origin) => `${separator}${origin.toLowerCase()}`);\n}\n\n/\n 生成随机字符串\n * @param {number} length - 生成的随机字符串长度\n * @param {string} [dict] - 用于生成随机字符串的字符字典，默认为数字、小写字母和大写字母的组合\n * @returns {string} - 生成的随机字符串\n * @example\n * randomString(10); // 生成一个长度为 10 的随机字符串\n * randomString(8, 'ABCDEF'); // 生成一个长度为 8 的随机字符串，仅包含字符 'ABCDEF'\n /\nexport function randomString(length: number, dict?: string): string {\n const dictFinal = dict \|\| STRING_DICT;\n const dictLength = dictFinal.length;\n\n let result = '';\n\n for (let i = 0; i < length; i++) {\n result += dictFinal.charAt(randomNumber(0, dictLength - 1));\n }\n\n return result;\n}\n\n/\n 简单的模板引擎，类似于 Python 的 `.format()` 方法\n * 支持通过索引或对象/名称的方式传递变量\n * 当使用对象/名称方式时，可以传递一个回退值作为第三个参数\n \n @category 字符串\n * @example\n * ```\n * // 索引方式\n * const result = stringFormat(\n * '你好 {0}！我的名字是 {1}。',\n * '张三',\n * '李四'\n * ); // 你好张三！我的名字是李四。\n * ```\n \n @example\n * ```\n * // 对象方式\n * const result = stringFormat(\n * '{greet}！我的名字是 {name}。',\n * { greet: '你好', name: '王五' }\n * ); // 你好！我的名字是王五。\n * ```\n \n @example\n * ```\n * // 带回退值的对象方式\n * const result = stringFormat(\n * '{greet}！我的名字是 {name}。',\n * { greet: '你好' }, // name 未传递，因此会使用回退值\n * '未知'\n * ); // 你好！我的名字是未知。\n * ```\n /\nexport function stringFormat(\n str: string,\n object: Record<string \| number, unknown>,\n fallback?: string \| ((key: string) => string),\n): string;\nexport function stringFormat(str: string, ...args: (string \| number \| bigint \| undefined \| null)[]): string;\nexport function stringFormat(str: string, ...args: unknown[]): string {\n const [firstArg, fallback] = args;\n\n if (isObject(firstArg) \|\| isUndefined(firstArg)) {\n const vars = firstArg \|\| {};\n return str.replace(/\\{(\\w+)\\}/g, (_, key) => vars[key] ?? (isFunction(fallback) ? fallback(key) : fallback) ?? key);\n }\n\n return str.replace(/\\{(\\d+)\\}/g, (_, key) => {\n const index = Number(key);\n if (Number.isNaN(index)) return key;\n return args[index];\n });\n}\n\n/\n 生成符合 [RFC 4122](https://www.ietf.org/rfc/rfc4122.txt) 版本 4 的 UUID 字符串\n * @returns {string} - 生成的 UUID 字符串\n * @example\n * const uuid = randomUUID4();\n * console.log(uuid); // 输出类似 '123e4567-e89b-12d3-a456-426614174000' 的 UUID 字符串\n /\nexport function randomUUID4(): string {\n const template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';\n let result = '';\n\n for (let i = 0; i < template.length; i++) {\n const t = template[i];\n\n if (t === '-' \|\| t === '4') {\n result += t;\n continue;\n }\n\n if (t === 'y') {\n result += randomString(1, '89ab');\n continue;\n }\n\n result += randomString(1, STRING_HEXADECIMALS);\n }\n\n return result;\n}\n\n/\n 将值转换为字符串，若值为 null 或 undefined 则返回空字符串\n * @param {unknown} value - 需要转换的值\n * @returns {string} 转换后的字符串结果\n */\nexport function stringify(value: unknown) {\n return isNullish(value) ? '' : String(value);\n}\n"],"mappings":"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"}

package/dist/time.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"time.cjs","names":[],"sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport {\n DATE_DAY_MS~~,\n~~ DATE_HOUR_MS~~,\n~~ DATE_MINUTE_MS~~,\n~~ DATE_MONTH_MS~~,\n~~ DATE_SECOND_MS~~,\n~~ DATE_YEAR_MS~~,\n~~} from '@/date';\nimport { isString } from '@/type';\nimport type { TimeDuration } from './to';\n\n/*\n 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n /\nconst rules: [key: keyof TimeDuration, time: number][] = [\n ['years', DATE_YEAR_MS],\n ['months', DATE_MONTH_MS],\n ['days', DATE_DAY_MS],\n ['hours', DATE_HOUR_MS],\n ['minutes', DATE_MINUTE_MS],\n ['seconds', DATE_SECOND_MS],\n];\n\n/\n 将时间持续时间字符串或对象转换为毫秒数\n \n @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象\n * @returns 计算得到的总毫秒数\n /\nexport function timeFrom(duration: string \| TimeDuration) {\n const td = isString(duration) ? timeParse(duration) : duration;\n return rules.reduce((acc, [key, time]) => acc + (td[key] \|\| 0) time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TimeDuration][] = [\n [/(\\d+)y/i, 'years'],\n [/(\\d+)M/, 'months'],\n [/(\\d+)d/i, 'days'],\n [/(\\d+)h/i, 'hours'],\n [/(\\d+)m/, 'minutes'],\n [/(\\d+)s/, 'seconds'],\n];\n\n/*\n 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n /\nexport function timeParse(duration: string) {\n const result = {} as TimeDuration;\n\n for (const [regex, key] of durationMatchRules) {\n const match = duration.match(regex);\n if (match) result[key] = Number(match[1]);\n else result[key] = 0;\n }\n\n return result;\n}\n","import {\n DATE_DAY_MS~~,\n~~ DATE_HOUR_MS~~,\n~~ DATE_MINUTE_MS~~,\n~~ DATE_SECOND_MS~~,\n~~} from '../date';\n\nexport type TimeDuration = {\n years: number;\n months: number;\n /* 天数 /\n days: number;\n /* 小时数 /\n hours: number;\n /* 分钟数 /\n minutes: number;\n /* 秒数 /\n seconds: number;\n /* 毫秒数 /\n milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' \| 'h' \| 'm' \| 's' \| 'S';\n\n/\n 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n \n // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n /\nfunction _timeAbsolute(\n timeMs: number~~,\n~~ maxPoint: _TTimeParsePoint~~,\n~~): TimeDuration {\n const minPoint: _TTimeParsePoint = 'S';\n\n const defines: [\n point: _TTimeParsePoint~~,\n~~ key: keyof TimeDuration~~,\n~~ base: number~~,\n~~ ][] = [\n ['D', 'days', DATE_DAY_MS],\n ['h', 'hours', DATE_HOUR_MS],\n ['m', 'minutes', DATE_MINUTE_MS],\n ['s', 'seconds', DATE_SECOND_MS],\n ['S', 'milliseconds', 1],\n ] as const;\n\n const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n let timeMsFinal = timeMs;\n const dao: TimeDuration = {\n years: 0,\n months: 0,\n days: 0,\n hours: 0,\n minutes: 0,\n seconds: 0,\n milliseconds: 0,\n };\n\n for (let i = minIndex; i <= maxIndex; i++) {\n const mode = defines[i];\n const base = mode[2];\n const value = Math.floor(timeMsFinal / base);\n timeMsFinal = timeMsFinal - value base;\n dao[mode[1]] = value;\n }\n\n return dao;\n}\n\n/*\n 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n /\nexport function timeToDays(timeMs: number) {\n return _timeAbsolute(timeMs, 'D');\n}\n\n/\n 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n /\nexport function timeToHours(timeMs: number) {\n return _timeAbsolute(timeMs, 'h');\n}\n\n/\n 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n /\nexport function timeToMinutes(timeMs: number) {\n return _timeAbsolute(timeMs, 'm');\n}\n\n/\n 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n return _timeAbsolute(timeMs, 's');\n}\n"],"mappings":";;;;;;;;;;~~AAmBA~~,IAAM,QAAmD;CACvD,CAAC,SAAS,aAAA,aAAa;CACvB,CAAC,UAAU,aAAA,cAAc;CACzB,CAAC,QAAQ,aAAA,YAAY;CACrB,CAAC,SAAS,aAAA,aAAa;CACvB,CAAC,WAAW,aAAA,eAAe;CAC3B,CAAC,WAAW,aAAA,eAAe;CAC5B;;;;;;;AAQD,SAAgB,SAAS,UAAiC;CACxD,MAAM,KAAK,aAAA,SAAS,SAAS,GAAG,UAAU,SAAS,GAAG;CACtD,OAAO,MAAM,QAAQ,KAAK,CAAC,KAAK,UAAU,OAAO,GAAG,QAAQ,KAAK,MAAM,EAAE;;AAG3E,IAAM,qBAA0D;CAC9D,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,SAAS;CACpB,CAAC,WAAW,OAAO;CACnB,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,UAAU;CACrB,CAAC,UAAU,UAAU;CACtB;;;;;;AAOD,SAAgB,UAAU,UAAkB;CAC1C,MAAM,SAAS,EAAE;CAEjB,KAAK,MAAM,CAAC,OAAO,QAAQ,oBAAoB;EAC7C,MAAM,QAAQ,SAAS,MAAM,MAAM;EACnC,IAAI,OAAO,OAAO,OAAO,OAAO,MAAM,GAAG;OACpC,OAAO,OAAO;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;;~~ACtBT~~,SAAS,~~cACP~~,~~QACA~~,~~UACc~~;~~CACd~~,MAAM,WAA6B;CAEnC,MAAM,~~UAIA~~;~~EACJ~~;GAAC;GAAK;GAAQ,aAAA;GAAY;EAC1B;GAAC;GAAK;GAAS,aAAA;GAAa;EAC5B;GAAC;GAAK;GAAW,aAAA;GAAe;EAChC;GAAC;GAAK;GAAW,aAAA;GAAe;EAChC;GAAC;GAAK;GAAgB;GAAE;EACzB;CAED,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAClE,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAElE,IAAI,cAAc;CAClB,MAAM,MAAoB;EACxB,OAAO;EACP,QAAQ;EACR,MAAM;EACN,OAAO;EACP,SAAS;EACT,SAAS;EACT,cAAc;EACf;CAED,KAAK,IAAI,IAAI,UAAU,KAAK,UAAU,KAAK;EACzC,MAAM,OAAO,QAAQ;EACrB,MAAM,OAAO,KAAK;EAClB,MAAM,QAAQ,KAAK,MAAM,cAAc,KAAK;EAC5C,cAAc,cAAc,QAAQ;EACpC,IAAI,KAAK,MAAM;;CAGjB,OAAO;;;;;;;AAQT,SAAgB,WAAW,QAAgB;CACzC,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,YAAY,QAAgB;CAC1C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI"}
1	+ {"version":3,"file":"time.cjs","names":[],"sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_MONTH_MS, DATE_SECOND_MS, DATE_YEAR_MS } from '@/date';\nimport { isString } from '@/type';\nimport type { TimeDuration } from './to';\n\n/*\n 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n /\nconst rules: [key: keyof TimeDuration, time: number][] = [\n ['years', DATE_YEAR_MS],\n ['months', DATE_MONTH_MS],\n ['days', DATE_DAY_MS],\n ['hours', DATE_HOUR_MS],\n ['minutes', DATE_MINUTE_MS],\n ['seconds', DATE_SECOND_MS],\n];\n\n/\n 将时间持续时间字符串或对象转换为毫秒数\n \n @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象\n * @returns 计算得到的总毫秒数\n /\nexport function timeFrom(duration: string \| TimeDuration) {\n const td = isString(duration) ? timeParse(duration) : duration;\n return rules.reduce((acc, [key, time]) => acc + (td[key] \|\| 0) time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TimeDuration][] = [\n [/(\\d+)y/i, 'years'],\n [/(\\d+)M/, 'months'],\n [/(\\d+)d/i, 'days'],\n [/(\\d+)h/i, 'hours'],\n [/(\\d+)m/, 'minutes'],\n [/(\\d+)s/, 'seconds'],\n];\n\n/*\n 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n /\nexport function timeParse(duration: string) {\n const result = {} as TimeDuration;\n\n for (const [regex, key] of durationMatchRules) {\n const match = duration.match(regex);\n if (match) result[key] = Number(match[1]);\n else result[key] = 0;\n }\n\n return result;\n}\n","import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_SECOND_MS } from '../date';\n\nexport type TimeDuration = {\n years: number;\n months: number;\n /* 天数 /\n days: number;\n /* 小时数 /\n hours: number;\n /* 分钟数 /\n minutes: number;\n /* 秒数 /\n seconds: number;\n /* 毫秒数 /\n milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' \| 'h' \| 'm' \| 's' \| 'S';\n\n/\n 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n \n // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n /\nfunction _timeAbsolute(timeMs: number, maxPoint: _TTimeParsePoint): TimeDuration {\n const minPoint: _TTimeParsePoint = 'S';\n\n const defines: [point: _TTimeParsePoint, key: keyof TimeDuration, base: number][] = [\n ['D', 'days', DATE_DAY_MS],\n ['h', 'hours', DATE_HOUR_MS],\n ['m', 'minutes', DATE_MINUTE_MS],\n ['s', 'seconds', DATE_SECOND_MS],\n ['S', 'milliseconds', 1],\n ] as const;\n\n const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n let timeMsFinal = timeMs;\n const dao: TimeDuration = {\n years: 0,\n months: 0,\n days: 0,\n hours: 0,\n minutes: 0,\n seconds: 0,\n milliseconds: 0,\n };\n\n for (let i = minIndex; i <= maxIndex; i++) {\n const mode = defines[i];\n const base = mode[2];\n const value = Math.floor(timeMsFinal / base);\n timeMsFinal = timeMsFinal - value base;\n dao[mode[1]] = value;\n }\n\n return dao;\n}\n\n/*\n 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n /\nexport function timeToDays(timeMs: number) {\n return _timeAbsolute(timeMs, 'D');\n}\n\n/\n 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n /\nexport function timeToHours(timeMs: number) {\n return _timeAbsolute(timeMs, 'h');\n}\n\n/\n 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n /\nexport function timeToMinutes(timeMs: number) {\n return _timeAbsolute(timeMs, 'm');\n}\n\n/\n 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n return _timeAbsolute(timeMs, 's');\n}\n"],"mappings":";;;;;;;;;;AAYA,IAAM,QAAmD;CACvD,CAAC,SAAS,aAAA,aAAa;CACvB,CAAC,UAAU,aAAA,cAAc;CACzB,CAAC,QAAQ,aAAA,YAAY;CACrB,CAAC,SAAS,aAAA,aAAa;CACvB,CAAC,WAAW,aAAA,eAAe;CAC3B,CAAC,WAAW,aAAA,eAAe;CAC5B;;;;;;;AAQD,SAAgB,SAAS,UAAiC;CACxD,MAAM,KAAK,aAAA,SAAS,SAAS,GAAG,UAAU,SAAS,GAAG;CACtD,OAAO,MAAM,QAAQ,KAAK,CAAC,KAAK,UAAU,OAAO,GAAG,QAAQ,KAAK,MAAM,EAAE;;AAG3E,IAAM,qBAA0D;CAC9D,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,SAAS;CACpB,CAAC,WAAW,OAAO;CACnB,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,UAAU;CACrB,CAAC,UAAU,UAAU;CACtB;;;;;;AAOD,SAAgB,UAAU,UAAkB;CAC1C,MAAM,SAAS,EAAE;CAEjB,KAAK,MAAM,CAAC,OAAO,QAAQ,oBAAoB;EAC7C,MAAM,QAAQ,SAAS,MAAM,MAAM;EACnC,IAAI,OAAO,OAAO,OAAO,OAAO,MAAM,GAAG;OACpC,OAAO,OAAO;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;;ACpBT,SAAS,cAAc,QAAgB,UAA0C;CAC/E,MAAM,WAA6B;CAEnC,MAAM,UAA8E;EAClF;GAAC;GAAK;GAAQ,aAAA;GAAY;EAC1B;GAAC;GAAK;GAAS,aAAA;GAAa;EAC5B;GAAC;GAAK;GAAW,aAAA;GAAe;EAChC;GAAC;GAAK;GAAW,aAAA;GAAe;EAChC;GAAC;GAAK;GAAgB;GAAE;EACzB;CAED,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAClE,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAElE,IAAI,cAAc;CAClB,MAAM,MAAoB;EACxB,OAAO;EACP,QAAQ;EACR,MAAM;EACN,OAAO;EACP,SAAS;EACT,SAAS;EACT,cAAc;EACf;CAED,KAAK,IAAI,IAAI,UAAU,KAAK,UAAU,KAAK;EACzC,MAAM,OAAO,QAAQ;EACrB,MAAM,OAAO,KAAK;EAClB,MAAM,QAAQ,KAAK,MAAM,cAAc,KAAK;EAC5C,cAAc,cAAc,QAAQ;EACpC,IAAI,KAAK,MAAM;;CAGjB,OAAO;;;;;;;AAQT,SAAgB,WAAW,QAAgB;CACzC,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,YAAY,QAAgB;CAC1C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI"}

package/dist/time.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"time.mjs","names":[],"sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport {\n DATE_DAY_MS~~,\n~~ DATE_HOUR_MS~~,\n~~ DATE_MINUTE_MS~~,\n~~ DATE_MONTH_MS~~,\n~~ DATE_SECOND_MS~~,\n~~ DATE_YEAR_MS~~,\n~~} from '@/date';\nimport { isString } from '@/type';\nimport type { TimeDuration } from './to';\n\n/*\n 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n /\nconst rules: [key: keyof TimeDuration, time: number][] = [\n ['years', DATE_YEAR_MS],\n ['months', DATE_MONTH_MS],\n ['days', DATE_DAY_MS],\n ['hours', DATE_HOUR_MS],\n ['minutes', DATE_MINUTE_MS],\n ['seconds', DATE_SECOND_MS],\n];\n\n/\n 将时间持续时间字符串或对象转换为毫秒数\n \n @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象\n * @returns 计算得到的总毫秒数\n /\nexport function timeFrom(duration: string \| TimeDuration) {\n const td = isString(duration) ? timeParse(duration) : duration;\n return rules.reduce((acc, [key, time]) => acc + (td[key] \|\| 0) time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TimeDuration][] = [\n [/(\\d+)y/i, 'years'],\n [/(\\d+)M/, 'months'],\n [/(\\d+)d/i, 'days'],\n [/(\\d+)h/i, 'hours'],\n [/(\\d+)m/, 'minutes'],\n [/(\\d+)s/, 'seconds'],\n];\n\n/*\n 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n /\nexport function timeParse(duration: string) {\n const result = {} as TimeDuration;\n\n for (const [regex, key] of durationMatchRules) {\n const match = duration.match(regex);\n if (match) result[key] = Number(match[1]);\n else result[key] = 0;\n }\n\n return result;\n}\n","import {\n DATE_DAY_MS~~,\n~~ DATE_HOUR_MS~~,\n~~ DATE_MINUTE_MS~~,\n~~ DATE_SECOND_MS~~,\n~~} from '../date';\n\nexport type TimeDuration = {\n years: number;\n months: number;\n /* 天数 /\n days: number;\n /* 小时数 /\n hours: number;\n /* 分钟数 /\n minutes: number;\n /* 秒数 /\n seconds: number;\n /* 毫秒数 /\n milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' \| 'h' \| 'm' \| 's' \| 'S';\n\n/\n 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n \n // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n /\nfunction _timeAbsolute(\n timeMs: number~~,\n~~ maxPoint: _TTimeParsePoint~~,\n~~): TimeDuration {\n const minPoint: _TTimeParsePoint = 'S';\n\n const defines: [\n point: _TTimeParsePoint~~,\n~~ key: keyof TimeDuration~~,\n~~ base: number~~,\n~~ ][] = [\n ['D', 'days', DATE_DAY_MS],\n ['h', 'hours', DATE_HOUR_MS],\n ['m', 'minutes', DATE_MINUTE_MS],\n ['s', 'seconds', DATE_SECOND_MS],\n ['S', 'milliseconds', 1],\n ] as const;\n\n const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n let timeMsFinal = timeMs;\n const dao: TimeDuration = {\n years: 0,\n months: 0,\n days: 0,\n hours: 0,\n minutes: 0,\n seconds: 0,\n milliseconds: 0,\n };\n\n for (let i = minIndex; i <= maxIndex; i++) {\n const mode = defines[i];\n const base = mode[2];\n const value = Math.floor(timeMsFinal / base);\n timeMsFinal = timeMsFinal - value base;\n dao[mode[1]] = value;\n }\n\n return dao;\n}\n\n/*\n 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n /\nexport function timeToDays(timeMs: number) {\n return _timeAbsolute(timeMs, 'D');\n}\n\n/\n 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n /\nexport function timeToHours(timeMs: number) {\n return _timeAbsolute(timeMs, 'h');\n}\n\n/\n 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n /\nexport function timeToMinutes(timeMs: number) {\n return _timeAbsolute(timeMs, 'm');\n}\n\n/\n 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n return _timeAbsolute(timeMs, 's');\n}\n"],"mappings":";;;;;;;;;~~AAmBA~~,IAAM,QAAmD;CACvD,CAAC,SAAS,aAAa;CACvB,CAAC,UAAU,cAAc;CACzB,CAAC,QAAQ,YAAY;CACrB,CAAC,SAAS,aAAa;CACvB,CAAC,WAAW,eAAe;CAC3B,CAAC,WAAW,eAAe;CAC5B;;;;;;;AAQD,SAAgB,SAAS,UAAiC;CACxD,MAAM,KAAK,SAAS,SAAS,GAAG,UAAU,SAAS,GAAG;CACtD,OAAO,MAAM,QAAQ,KAAK,CAAC,KAAK,UAAU,OAAO,GAAG,QAAQ,KAAK,MAAM,EAAE;;AAG3E,IAAM,qBAA0D;CAC9D,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,SAAS;CACpB,CAAC,WAAW,OAAO;CACnB,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,UAAU;CACrB,CAAC,UAAU,UAAU;CACtB;;;;;;AAOD,SAAgB,UAAU,UAAkB;CAC1C,MAAM,SAAS,EAAE;CAEjB,KAAK,MAAM,CAAC,OAAO,QAAQ,oBAAoB;EAC7C,MAAM,QAAQ,SAAS,MAAM,MAAM;EACnC,IAAI,OAAO,OAAO,OAAO,OAAO,MAAM,GAAG;OACpC,OAAO,OAAO;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;;~~ACtBT~~,SAAS,~~cACP~~,~~QACA~~,~~UACc~~;~~CACd~~,MAAM,WAA6B;CAEnC,MAAM,~~UAIA~~;~~EACJ~~;GAAC;GAAK;GAAQ;GAAY;EAC1B;GAAC;GAAK;GAAS;GAAa;EAC5B;GAAC;GAAK;GAAW;GAAe;EAChC;GAAC;GAAK;GAAW;GAAe;EAChC;GAAC;GAAK;GAAgB;GAAE;EACzB;CAED,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAClE,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAElE,IAAI,cAAc;CAClB,MAAM,MAAoB;EACxB,OAAO;EACP,QAAQ;EACR,MAAM;EACN,OAAO;EACP,SAAS;EACT,SAAS;EACT,cAAc;EACf;CAED,KAAK,IAAI,IAAI,UAAU,KAAK,UAAU,KAAK;EACzC,MAAM,OAAO,QAAQ;EACrB,MAAM,OAAO,KAAK;EAClB,MAAM,QAAQ,KAAK,MAAM,cAAc,KAAK;EAC5C,cAAc,cAAc,QAAQ;EACpC,IAAI,KAAK,MAAM;;CAGjB,OAAO;;;;;;;AAQT,SAAgB,WAAW,QAAgB;CACzC,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,YAAY,QAAgB;CAC1C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI"}
1	+ {"version":3,"file":"time.mjs","names":[],"sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_MONTH_MS, DATE_SECOND_MS, DATE_YEAR_MS } from '@/date';\nimport { isString } from '@/type';\nimport type { TimeDuration } from './to';\n\n/*\n 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n /\nconst rules: [key: keyof TimeDuration, time: number][] = [\n ['years', DATE_YEAR_MS],\n ['months', DATE_MONTH_MS],\n ['days', DATE_DAY_MS],\n ['hours', DATE_HOUR_MS],\n ['minutes', DATE_MINUTE_MS],\n ['seconds', DATE_SECOND_MS],\n];\n\n/\n 将时间持续时间字符串或对象转换为毫秒数\n \n @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象\n * @returns 计算得到的总毫秒数\n /\nexport function timeFrom(duration: string \| TimeDuration) {\n const td = isString(duration) ? timeParse(duration) : duration;\n return rules.reduce((acc, [key, time]) => acc + (td[key] \|\| 0) time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TimeDuration][] = [\n [/(\\d+)y/i, 'years'],\n [/(\\d+)M/, 'months'],\n [/(\\d+)d/i, 'days'],\n [/(\\d+)h/i, 'hours'],\n [/(\\d+)m/, 'minutes'],\n [/(\\d+)s/, 'seconds'],\n];\n\n/*\n 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n /\nexport function timeParse(duration: string) {\n const result = {} as TimeDuration;\n\n for (const [regex, key] of durationMatchRules) {\n const match = duration.match(regex);\n if (match) result[key] = Number(match[1]);\n else result[key] = 0;\n }\n\n return result;\n}\n","import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_SECOND_MS } from '../date';\n\nexport type TimeDuration = {\n years: number;\n months: number;\n /* 天数 /\n days: number;\n /* 小时数 /\n hours: number;\n /* 分钟数 /\n minutes: number;\n /* 秒数 /\n seconds: number;\n /* 毫秒数 /\n milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' \| 'h' \| 'm' \| 's' \| 'S';\n\n/\n 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n \n // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n /\nfunction _timeAbsolute(timeMs: number, maxPoint: _TTimeParsePoint): TimeDuration {\n const minPoint: _TTimeParsePoint = 'S';\n\n const defines: [point: _TTimeParsePoint, key: keyof TimeDuration, base: number][] = [\n ['D', 'days', DATE_DAY_MS],\n ['h', 'hours', DATE_HOUR_MS],\n ['m', 'minutes', DATE_MINUTE_MS],\n ['s', 'seconds', DATE_SECOND_MS],\n ['S', 'milliseconds', 1],\n ] as const;\n\n const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n let timeMsFinal = timeMs;\n const dao: TimeDuration = {\n years: 0,\n months: 0,\n days: 0,\n hours: 0,\n minutes: 0,\n seconds: 0,\n milliseconds: 0,\n };\n\n for (let i = minIndex; i <= maxIndex; i++) {\n const mode = defines[i];\n const base = mode[2];\n const value = Math.floor(timeMsFinal / base);\n timeMsFinal = timeMsFinal - value base;\n dao[mode[1]] = value;\n }\n\n return dao;\n}\n\n/*\n 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n /\nexport function timeToDays(timeMs: number) {\n return _timeAbsolute(timeMs, 'D');\n}\n\n/\n 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n /\nexport function timeToHours(timeMs: number) {\n return _timeAbsolute(timeMs, 'h');\n}\n\n/\n 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n /\nexport function timeToMinutes(timeMs: number) {\n return _timeAbsolute(timeMs, 'm');\n}\n\n/\n 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n return _timeAbsolute(timeMs, 's');\n}\n"],"mappings":";;;;;;;;;AAYA,IAAM,QAAmD;CACvD,CAAC,SAAS,aAAa;CACvB,CAAC,UAAU,cAAc;CACzB,CAAC,QAAQ,YAAY;CACrB,CAAC,SAAS,aAAa;CACvB,CAAC,WAAW,eAAe;CAC3B,CAAC,WAAW,eAAe;CAC5B;;;;;;;AAQD,SAAgB,SAAS,UAAiC;CACxD,MAAM,KAAK,SAAS,SAAS,GAAG,UAAU,SAAS,GAAG;CACtD,OAAO,MAAM,QAAQ,KAAK,CAAC,KAAK,UAAU,OAAO,GAAG,QAAQ,KAAK,MAAM,EAAE;;AAG3E,IAAM,qBAA0D;CAC9D,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,SAAS;CACpB,CAAC,WAAW,OAAO;CACnB,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,UAAU;CACrB,CAAC,UAAU,UAAU;CACtB;;;;;;AAOD,SAAgB,UAAU,UAAkB;CAC1C,MAAM,SAAS,EAAE;CAEjB,KAAK,MAAM,CAAC,OAAO,QAAQ,oBAAoB;EAC7C,MAAM,QAAQ,SAAS,MAAM,MAAM;EACnC,IAAI,OAAO,OAAO,OAAO,OAAO,MAAM,GAAG;OACpC,OAAO,OAAO;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;;ACpBT,SAAS,cAAc,QAAgB,UAA0C;CAC/E,MAAM,WAA6B;CAEnC,MAAM,UAA8E;EAClF;GAAC;GAAK;GAAQ;GAAY;EAC1B;GAAC;GAAK;GAAS;GAAa;EAC5B;GAAC;GAAK;GAAW;GAAe;EAChC;GAAC;GAAK;GAAW;GAAe;EAChC;GAAC;GAAK;GAAgB;GAAE;EACzB;CAED,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAClE,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAElE,IAAI,cAAc;CAClB,MAAM,MAAoB;EACxB,OAAO;EACP,QAAQ;EACR,MAAM;EACN,OAAO;EACP,SAAS;EACT,SAAS;EACT,cAAc;EACf;CAED,KAAK,IAAI,IAAI,UAAU,KAAK,UAAU,KAAK;EACzC,MAAM,OAAO,QAAQ;EACrB,MAAM,OAAO,KAAK;EAClB,MAAM,QAAQ,KAAK,MAAM,cAAc,KAAK;EAC5C,cAAc,cAAc,QAAQ;EACpC,IAAI,KAAK,MAAM;;CAGjB,OAAO;;;;;;;AAQT,SAAgB,WAAW,QAAgB;CACzC,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,YAAY,QAAgB;CAC1C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI"}

package/dist/timer.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"timer.cjs","names":[],"sources":["../src/timer.ts"],"sourcesContent":["/*\n 定时器状态接口\n /\nexport type TimerState = {\n /\n 执行次数\n /\n times: number;\n /\n 开始时间戳\n /\n startAt: number;\n /\n 停止时间戳\n /\n stopAt: number;\n /\n 暂停时间戳\n /\n pauseAt: number;\n /\n 恢复时间戳\n /\n resumeAt: number;\n /\n 当前时间戳\n /\n currentAt: number;\n /\n 总耗时（包括暂停时间）\n /\n elapsedTime: number;\n /\n 实际运行时间（不包括暂停时间）\n /\n runningTime: number;\n /\n 当前间隔时间\n /\n intervalTime: number;\n};\n\nexport type TimerHandler = {\n /\n 开始\n /\n start: () => void;\n /\n 暂停\n /\n pause: () => void;\n /\n 恢复\n /\n resume: (immediate?: boolean) => void;\n /\n 停止\n /\n stop: () => void;\n};\n\nconst STATUS_READY = 0;\nconst STATUS_START = 1;\nconst STATUS_PAUSE = 2;\nconst STATUS_STOP = 3;\n\n/\n 创建间隔定时器核心函数\n \n @param nextTime - 用于安排下一次执行的函数\n * @param effect - 每次执行的回调函数，接收定时器状态和可选的next函数\n * @returns 返回包含控制方法的对象\n /\nexport function makeInterval(\n nextTime: (call: () => void) => void,\n effect: (timer: TimerState, next?: () => void) => unknown,\n) {\n let startAt = 0;\n let lastAt = 0;\n let stopAt = 0;\n let pauseAt = 0;\n let resumeAt = 0;\n let times = 0;\n let status = STATUS_READY;\n let runningTime = 0;\n\n const execute = () => {\n if (status >= STATUS_PAUSE) return;\n\n const now = Date.now();\n const intervalTime = lastAt > 0 ? now - lastAt : 0;\n runningTime += intervalTime;\n lastAt = now;\n const state: TimerState = {\n times: ++times,\n startAt,\n stopAt,\n pauseAt,\n resumeAt,\n currentAt: now,\n elapsedTime: startAt > 0 ? now - startAt : 0,\n runningTime,\n intervalTime,\n };\n\n if (effect.length === 2) {\n effect(state, () => {\n nextTime(execute);\n });\n } else {\n effect(state);\n nextTime(execute);\n }\n };\n\n const canStart = () => status === STATUS_READY;\n const start = () => {\n if (!canStart()) return;\n status = STATUS_START;\n startAt = Date.now();\n execute();\n };\n\n const canStop = () => status === STATUS_START;\n const stop = () => {\n if (!canStop()) return;\n status = STATUS_STOP;\n stopAt = Date.now();\n };\n\n const canPause = () => status === STATUS_START;\n const pause = () => {\n if (!canPause()) return;\n status = STATUS_PAUSE;\n pauseAt = Date.now();\n };\n\n const canResume = () => status === STATUS_PAUSE;\n const resume = () => {\n if (!canResume()) return;\n status = STATUS_START;\n resumeAt = Date.now();\n lastAt = resumeAt;\n execute();\n };\n\n return {\n canStart,\n canStop,\n canPause,\n canResume,\n start,\n stop,\n pause,\n resume,\n execute,\n };\n}\n\nexport type TimerOptions = {\n /\n 是否在定时器开始时立即执行回调\n /\n leading?: boolean;\n /\n 是否在定时器停止时执行最后一次回调\n /\n trailing?: boolean;\n};\n\n/\n 创建一个基于 `setTimeout` 的间隔定时器\n \n @param callback - 每次间隔执行的回调函数，接收定时器状态和可选的 `next` 函数\n * @param interval - 间隔时间，单位为毫秒\n * @param options - 配置选项\n * @returns {TimerHandler}\n */\nexport function timeInterval(\n callback: (state: TimerState, next?: () => void) => unknown,\n interval: number,\n options?: TimerOptions,\n): TimerHandler {\n let timeId: number \| NodeJS.Timeout;\n const {\n canStart~~,\n~~ canStop~~,\n~~ canPause~~,\n~~ canResume~~,\n~~ start~~,\n~~ stop~~,\n~~ pause~~,\n~~ resume~~,\n~~ execute~~,\n~~ } = makeInterval((call) => {\n timeId = setTimeout(call, interval);\n }, callback);\n\n return {\n start() {\n if (!canStart()) return;\n\n if (options?.leading) {\n start();\n } else {\n timeId = setTimeout(start, interval);\n }\n },\n\n stop() {\n if (!canStop()) return;\n if (options?.trailing) execute();\n\n clearTimeout(timeId);\n stop();\n },\n\n pause() {\n if (!canPause()) return;\n if (options?.trailing) execute();\n\n clearTimeout(timeId);\n pause();\n },\n\n resume(immediate?: boolean) {\n if (!canResume()) return;\n\n if (immediate \|\| options?.leading) {\n resume();\n } else {\n timeId = setTimeout(resume, interval);\n }\n },\n };\n}\n"],"mappings":";;AA6DA,IAAM,eAAe;AACrB,IAAM,eAAe;AACrB,IAAM,eAAe;AACrB,IAAM,cAAc;;;;;;;;AASpB,SAAgB,aACd,UACA,QACA;CACA,IAAI,UAAU;CACd,IAAI,SAAS;CACb,IAAI,SAAS;CACb,IAAI,UAAU;CACd,IAAI,WAAW;CACf,IAAI,QAAQ;CACZ,IAAI,SAAS;CACb,IAAI,cAAc;CAElB,MAAM,gBAAgB;EACpB,IAAI,UAAU,cAAc;EAE5B,MAAM,MAAM,KAAK,KAAK;EACtB,MAAM,eAAe,SAAS,IAAI,MAAM,SAAS;EACjD,eAAe;EACf,SAAS;EACT,MAAM,QAAoB;GACxB,OAAO,EAAE;GACT;GACA;GACA;GACA;GACA,WAAW;GACX,aAAa,UAAU,IAAI,MAAM,UAAU;GAC3C;GACA;GACD;EAED,IAAI,OAAO,WAAW,GACpB,OAAO,aAAa;GAClB,SAAS,QAAQ;IACjB;OACG;GACL,OAAO,MAAM;GACb,SAAS,QAAQ;;;CAIrB,MAAM,iBAAiB,WAAW;CAClC,MAAM,cAAc;EAClB,IAAI,CAAC,UAAU,EAAE;EACjB,SAAS;EACT,UAAU,KAAK,KAAK;EACpB,SAAS;;CAGX,MAAM,gBAAgB,WAAW;CACjC,MAAM,aAAa;EACjB,IAAI,CAAC,SAAS,EAAE;EAChB,SAAS;EACT,SAAS,KAAK,KAAK;;CAGrB,MAAM,iBAAiB,WAAW;CAClC,MAAM,cAAc;EAClB,IAAI,CAAC,UAAU,EAAE;EACjB,SAAS;EACT,UAAU,KAAK,KAAK;;CAGtB,MAAM,kBAAkB,WAAW;CACnC,MAAM,eAAe;EACnB,IAAI,CAAC,WAAW,EAAE;EAClB,SAAS;EACT,WAAW,KAAK,KAAK;EACrB,SAAS;EACT,SAAS;;CAGX,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;;;;;;;;;;AAsBH,SAAgB,aACd,UACA,UACA,SACc;CACd,IAAI;CACJ,MAAM,~~EACJ~~,~~UACA~~,~~SACA~~,~~UACA~~,~~WACA~~,~~OACA~~,~~MACA~~,~~OACA~~,~~QACA~~,~~YACE~~,cAAc,SAAS;~~EACzB~~,SAAS,WAAW,MAAM,SAAS;IAClC,SAAS;CAEZ,OAAO;EACL,QAAQ;GACN,IAAI,CAAC,UAAU,EAAE;GAEjB,IAAI,SAAS,SACX,OAAO;QAEP,SAAS,WAAW,OAAO,SAAS;;EAIxC,OAAO;GACL,IAAI,CAAC,SAAS,EAAE;GAChB,IAAI,SAAS,UAAU,SAAS;GAEhC,aAAa,OAAO;GACpB,MAAM;;EAGR,QAAQ;GACN,IAAI,CAAC,UAAU,EAAE;GACjB,IAAI,SAAS,UAAU,SAAS;GAEhC,aAAa,OAAO;GACpB,OAAO;;EAGT,OAAO,WAAqB;GAC1B,IAAI,CAAC,WAAW,EAAE;GAElB,IAAI,aAAa,SAAS,SACxB,QAAQ;QAER,SAAS,WAAW,QAAQ,SAAS;;EAG1C"}
1	+ {"version":3,"file":"timer.cjs","names":[],"sources":["../src/timer.ts"],"sourcesContent":["/*\n 定时器状态接口\n /\nexport type TimerState = {\n /\n 执行次数\n /\n times: number;\n /\n 开始时间戳\n /\n startAt: number;\n /\n 停止时间戳\n /\n stopAt: number;\n /\n 暂停时间戳\n /\n pauseAt: number;\n /\n 恢复时间戳\n /\n resumeAt: number;\n /\n 当前时间戳\n /\n currentAt: number;\n /\n 总耗时（包括暂停时间）\n /\n elapsedTime: number;\n /\n 实际运行时间（不包括暂停时间）\n /\n runningTime: number;\n /\n 当前间隔时间\n /\n intervalTime: number;\n};\n\nexport type TimerHandler = {\n /\n 开始\n /\n start: () => void;\n /\n 暂停\n /\n pause: () => void;\n /\n 恢复\n /\n resume: (immediate?: boolean) => void;\n /\n 停止\n /\n stop: () => void;\n};\n\nconst STATUS_READY = 0;\nconst STATUS_START = 1;\nconst STATUS_PAUSE = 2;\nconst STATUS_STOP = 3;\n\n/\n 创建间隔定时器核心函数\n \n @param nextTime - 用于安排下一次执行的函数\n * @param effect - 每次执行的回调函数，接收定时器状态和可选的next函数\n * @returns 返回包含控制方法的对象\n /\nexport function makeInterval(\n nextTime: (call: () => void) => void,\n effect: (timer: TimerState, next?: () => void) => unknown,\n) {\n let startAt = 0;\n let lastAt = 0;\n let stopAt = 0;\n let pauseAt = 0;\n let resumeAt = 0;\n let times = 0;\n let status = STATUS_READY;\n let runningTime = 0;\n\n const execute = () => {\n if (status >= STATUS_PAUSE) return;\n\n const now = Date.now();\n const intervalTime = lastAt > 0 ? now - lastAt : 0;\n runningTime += intervalTime;\n lastAt = now;\n const state: TimerState = {\n times: ++times,\n startAt,\n stopAt,\n pauseAt,\n resumeAt,\n currentAt: now,\n elapsedTime: startAt > 0 ? now - startAt : 0,\n runningTime,\n intervalTime,\n };\n\n if (effect.length === 2) {\n effect(state, () => {\n nextTime(execute);\n });\n } else {\n effect(state);\n nextTime(execute);\n }\n };\n\n const canStart = () => status === STATUS_READY;\n const start = () => {\n if (!canStart()) return;\n status = STATUS_START;\n startAt = Date.now();\n execute();\n };\n\n const canStop = () => status === STATUS_START;\n const stop = () => {\n if (!canStop()) return;\n status = STATUS_STOP;\n stopAt = Date.now();\n };\n\n const canPause = () => status === STATUS_START;\n const pause = () => {\n if (!canPause()) return;\n status = STATUS_PAUSE;\n pauseAt = Date.now();\n };\n\n const canResume = () => status === STATUS_PAUSE;\n const resume = () => {\n if (!canResume()) return;\n status = STATUS_START;\n resumeAt = Date.now();\n lastAt = resumeAt;\n execute();\n };\n\n return {\n canStart,\n canStop,\n canPause,\n canResume,\n start,\n stop,\n pause,\n resume,\n execute,\n };\n}\n\nexport type TimerOptions = {\n /\n 是否在定时器开始时立即执行回调\n /\n leading?: boolean;\n /\n 是否在定时器停止时执行最后一次回调\n /\n trailing?: boolean;\n};\n\n/\n 创建一个基于 `setTimeout` 的间隔定时器\n \n @param callback - 每次间隔执行的回调函数，接收定时器状态和可选的 `next` 函数\n * @param interval - 间隔时间，单位为毫秒\n * @param options - 配置选项\n * @returns {TimerHandler}\n */\nexport function timeInterval(\n callback: (state: TimerState, next?: () => void) => unknown,\n interval: number,\n options?: TimerOptions,\n): TimerHandler {\n let timeId: number \| NodeJS.Timeout;\n const { canStart, canStop, canPause, canResume, start, stop, pause, resume, execute } = makeInterval((call) => {\n timeId = setTimeout(call, interval);\n }, callback);\n\n return {\n start() {\n if (!canStart()) return;\n\n if (options?.leading) {\n start();\n } else {\n timeId = setTimeout(start, interval);\n }\n },\n\n stop() {\n if (!canStop()) return;\n if (options?.trailing) execute();\n\n clearTimeout(timeId);\n stop();\n },\n\n pause() {\n if (!canPause()) return;\n if (options?.trailing) execute();\n\n clearTimeout(timeId);\n pause();\n },\n\n resume(immediate?: boolean) {\n if (!canResume()) return;\n\n if (immediate \|\| options?.leading) {\n resume();\n } else {\n timeId = setTimeout(resume, interval);\n }\n },\n };\n}\n"],"mappings":";;AA6DA,IAAM,eAAe;AACrB,IAAM,eAAe;AACrB,IAAM,eAAe;AACrB,IAAM,cAAc;;;;;;;;AASpB,SAAgB,aACd,UACA,QACA;CACA,IAAI,UAAU;CACd,IAAI,SAAS;CACb,IAAI,SAAS;CACb,IAAI,UAAU;CACd,IAAI,WAAW;CACf,IAAI,QAAQ;CACZ,IAAI,SAAS;CACb,IAAI,cAAc;CAElB,MAAM,gBAAgB;EACpB,IAAI,UAAU,cAAc;EAE5B,MAAM,MAAM,KAAK,KAAK;EACtB,MAAM,eAAe,SAAS,IAAI,MAAM,SAAS;EACjD,eAAe;EACf,SAAS;EACT,MAAM,QAAoB;GACxB,OAAO,EAAE;GACT;GACA;GACA;GACA;GACA,WAAW;GACX,aAAa,UAAU,IAAI,MAAM,UAAU;GAC3C;GACA;GACD;EAED,IAAI,OAAO,WAAW,GACpB,OAAO,aAAa;GAClB,SAAS,QAAQ;IACjB;OACG;GACL,OAAO,MAAM;GACb,SAAS,QAAQ;;;CAIrB,MAAM,iBAAiB,WAAW;CAClC,MAAM,cAAc;EAClB,IAAI,CAAC,UAAU,EAAE;EACjB,SAAS;EACT,UAAU,KAAK,KAAK;EACpB,SAAS;;CAGX,MAAM,gBAAgB,WAAW;CACjC,MAAM,aAAa;EACjB,IAAI,CAAC,SAAS,EAAE;EAChB,SAAS;EACT,SAAS,KAAK,KAAK;;CAGrB,MAAM,iBAAiB,WAAW;CAClC,MAAM,cAAc;EAClB,IAAI,CAAC,UAAU,EAAE;EACjB,SAAS;EACT,UAAU,KAAK,KAAK;;CAGtB,MAAM,kBAAkB,WAAW;CACnC,MAAM,eAAe;EACnB,IAAI,CAAC,WAAW,EAAE;EAClB,SAAS;EACT,WAAW,KAAK,KAAK;EACrB,SAAS;EACT,SAAS;;CAGX,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;;;;;;;;;;AAsBH,SAAgB,aACd,UACA,UACA,SACc;CACd,IAAI;CACJ,MAAM,EAAE,UAAU,SAAS,UAAU,WAAW,OAAO,MAAM,OAAO,QAAQ,YAAY,cAAc,SAAS;EAC7G,SAAS,WAAW,MAAM,SAAS;IAClC,SAAS;CAEZ,OAAO;EACL,QAAQ;GACN,IAAI,CAAC,UAAU,EAAE;GAEjB,IAAI,SAAS,SACX,OAAO;QAEP,SAAS,WAAW,OAAO,SAAS;;EAIxC,OAAO;GACL,IAAI,CAAC,SAAS,EAAE;GAChB,IAAI,SAAS,UAAU,SAAS;GAEhC,aAAa,OAAO;GACpB,MAAM;;EAGR,QAAQ;GACN,IAAI,CAAC,UAAU,EAAE;GACjB,IAAI,SAAS,UAAU,SAAS;GAEhC,aAAa,OAAO;GACpB,OAAO;;EAGT,OAAO,WAAqB;GAC1B,IAAI,CAAC,WAAW,EAAE;GAElB,IAAI,aAAa,SAAS,SACxB,QAAQ;QAER,SAAS,WAAW,QAAQ,SAAS;;EAG1C"}

package/dist/timer.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"timer.mjs","names":[],"sources":["../src/timer.ts"],"sourcesContent":["/*\n 定时器状态接口\n /\nexport type TimerState = {\n /\n 执行次数\n /\n times: number;\n /\n 开始时间戳\n /\n startAt: number;\n /\n 停止时间戳\n /\n stopAt: number;\n /\n 暂停时间戳\n /\n pauseAt: number;\n /\n 恢复时间戳\n /\n resumeAt: number;\n /\n 当前时间戳\n /\n currentAt: number;\n /\n 总耗时（包括暂停时间）\n /\n elapsedTime: number;\n /\n 实际运行时间（不包括暂停时间）\n /\n runningTime: number;\n /\n 当前间隔时间\n /\n intervalTime: number;\n};\n\nexport type TimerHandler = {\n /\n 开始\n /\n start: () => void;\n /\n 暂停\n /\n pause: () => void;\n /\n 恢复\n /\n resume: (immediate?: boolean) => void;\n /\n 停止\n /\n stop: () => void;\n};\n\nconst STATUS_READY = 0;\nconst STATUS_START = 1;\nconst STATUS_PAUSE = 2;\nconst STATUS_STOP = 3;\n\n/\n 创建间隔定时器核心函数\n \n @param nextTime - 用于安排下一次执行的函数\n * @param effect - 每次执行的回调函数，接收定时器状态和可选的next函数\n * @returns 返回包含控制方法的对象\n /\nexport function makeInterval(\n nextTime: (call: () => void) => void,\n effect: (timer: TimerState, next?: () => void) => unknown,\n) {\n let startAt = 0;\n let lastAt = 0;\n let stopAt = 0;\n let pauseAt = 0;\n let resumeAt = 0;\n let times = 0;\n let status = STATUS_READY;\n let runningTime = 0;\n\n const execute = () => {\n if (status >= STATUS_PAUSE) return;\n\n const now = Date.now();\n const intervalTime = lastAt > 0 ? now - lastAt : 0;\n runningTime += intervalTime;\n lastAt = now;\n const state: TimerState = {\n times: ++times,\n startAt,\n stopAt,\n pauseAt,\n resumeAt,\n currentAt: now,\n elapsedTime: startAt > 0 ? now - startAt : 0,\n runningTime,\n intervalTime,\n };\n\n if (effect.length === 2) {\n effect(state, () => {\n nextTime(execute);\n });\n } else {\n effect(state);\n nextTime(execute);\n }\n };\n\n const canStart = () => status === STATUS_READY;\n const start = () => {\n if (!canStart()) return;\n status = STATUS_START;\n startAt = Date.now();\n execute();\n };\n\n const canStop = () => status === STATUS_START;\n const stop = () => {\n if (!canStop()) return;\n status = STATUS_STOP;\n stopAt = Date.now();\n };\n\n const canPause = () => status === STATUS_START;\n const pause = () => {\n if (!canPause()) return;\n status = STATUS_PAUSE;\n pauseAt = Date.now();\n };\n\n const canResume = () => status === STATUS_PAUSE;\n const resume = () => {\n if (!canResume()) return;\n status = STATUS_START;\n resumeAt = Date.now();\n lastAt = resumeAt;\n execute();\n };\n\n return {\n canStart,\n canStop,\n canPause,\n canResume,\n start,\n stop,\n pause,\n resume,\n execute,\n };\n}\n\nexport type TimerOptions = {\n /\n 是否在定时器开始时立即执行回调\n /\n leading?: boolean;\n /\n 是否在定时器停止时执行最后一次回调\n /\n trailing?: boolean;\n};\n\n/\n 创建一个基于 `setTimeout` 的间隔定时器\n \n @param callback - 每次间隔执行的回调函数，接收定时器状态和可选的 `next` 函数\n * @param interval - 间隔时间，单位为毫秒\n * @param options - 配置选项\n * @returns {TimerHandler}\n */\nexport function timeInterval(\n callback: (state: TimerState, next?: () => void) => unknown,\n interval: number,\n options?: TimerOptions,\n): TimerHandler {\n let timeId: number \| NodeJS.Timeout;\n const {\n canStart~~,\n~~ canStop~~,\n~~ canPause~~,\n~~ canResume~~,\n~~ start~~,\n~~ stop~~,\n~~ pause~~,\n~~ resume~~,\n~~ execute~~,\n~~ } = makeInterval((call) => {\n timeId = setTimeout(call, interval);\n }, callback);\n\n return {\n start() {\n if (!canStart()) return;\n\n if (options?.leading) {\n start();\n } else {\n timeId = setTimeout(start, interval);\n }\n },\n\n stop() {\n if (!canStop()) return;\n if (options?.trailing) execute();\n\n clearTimeout(timeId);\n stop();\n },\n\n pause() {\n if (!canPause()) return;\n if (options?.trailing) execute();\n\n clearTimeout(timeId);\n pause();\n },\n\n resume(immediate?: boolean) {\n if (!canResume()) return;\n\n if (immediate \|\| options?.leading) {\n resume();\n } else {\n timeId = setTimeout(resume, interval);\n }\n },\n };\n}\n"],"mappings":";AA6DA,IAAM,eAAe;AACrB,IAAM,eAAe;AACrB,IAAM,eAAe;AACrB,IAAM,cAAc;;;;;;;;AASpB,SAAgB,aACd,UACA,QACA;CACA,IAAI,UAAU;CACd,IAAI,SAAS;CACb,IAAI,SAAS;CACb,IAAI,UAAU;CACd,IAAI,WAAW;CACf,IAAI,QAAQ;CACZ,IAAI,SAAS;CACb,IAAI,cAAc;CAElB,MAAM,gBAAgB;EACpB,IAAI,UAAU,cAAc;EAE5B,MAAM,MAAM,KAAK,KAAK;EACtB,MAAM,eAAe,SAAS,IAAI,MAAM,SAAS;EACjD,eAAe;EACf,SAAS;EACT,MAAM,QAAoB;GACxB,OAAO,EAAE;GACT;GACA;GACA;GACA;GACA,WAAW;GACX,aAAa,UAAU,IAAI,MAAM,UAAU;GAC3C;GACA;GACD;EAED,IAAI,OAAO,WAAW,GACpB,OAAO,aAAa;GAClB,SAAS,QAAQ;IACjB;OACG;GACL,OAAO,MAAM;GACb,SAAS,QAAQ;;;CAIrB,MAAM,iBAAiB,WAAW;CAClC,MAAM,cAAc;EAClB,IAAI,CAAC,UAAU,EAAE;EACjB,SAAS;EACT,UAAU,KAAK,KAAK;EACpB,SAAS;;CAGX,MAAM,gBAAgB,WAAW;CACjC,MAAM,aAAa;EACjB,IAAI,CAAC,SAAS,EAAE;EAChB,SAAS;EACT,SAAS,KAAK,KAAK;;CAGrB,MAAM,iBAAiB,WAAW;CAClC,MAAM,cAAc;EAClB,IAAI,CAAC,UAAU,EAAE;EACjB,SAAS;EACT,UAAU,KAAK,KAAK;;CAGtB,MAAM,kBAAkB,WAAW;CACnC,MAAM,eAAe;EACnB,IAAI,CAAC,WAAW,EAAE;EAClB,SAAS;EACT,WAAW,KAAK,KAAK;EACrB,SAAS;EACT,SAAS;;CAGX,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;;;;;;;;;;AAsBH,SAAgB,aACd,UACA,UACA,SACc;CACd,IAAI;CACJ,MAAM,~~EACJ~~,~~UACA~~,~~SACA~~,~~UACA~~,~~WACA~~,~~OACA~~,~~MACA~~,~~OACA~~,~~QACA~~,~~YACE~~,cAAc,SAAS;~~EACzB~~,SAAS,WAAW,MAAM,SAAS;IAClC,SAAS;CAEZ,OAAO;EACL,QAAQ;GACN,IAAI,CAAC,UAAU,EAAE;GAEjB,IAAI,SAAS,SACX,OAAO;QAEP,SAAS,WAAW,OAAO,SAAS;;EAIxC,OAAO;GACL,IAAI,CAAC,SAAS,EAAE;GAChB,IAAI,SAAS,UAAU,SAAS;GAEhC,aAAa,OAAO;GACpB,MAAM;;EAGR,QAAQ;GACN,IAAI,CAAC,UAAU,EAAE;GACjB,IAAI,SAAS,UAAU,SAAS;GAEhC,aAAa,OAAO;GACpB,OAAO;;EAGT,OAAO,WAAqB;GAC1B,IAAI,CAAC,WAAW,EAAE;GAElB,IAAI,aAAa,SAAS,SACxB,QAAQ;QAER,SAAS,WAAW,QAAQ,SAAS;;EAG1C"}
1	+ {"version":3,"file":"timer.mjs","names":[],"sources":["../src/timer.ts"],"sourcesContent":["/*\n 定时器状态接口\n /\nexport type TimerState = {\n /\n 执行次数\n /\n times: number;\n /\n 开始时间戳\n /\n startAt: number;\n /\n 停止时间戳\n /\n stopAt: number;\n /\n 暂停时间戳\n /\n pauseAt: number;\n /\n 恢复时间戳\n /\n resumeAt: number;\n /\n 当前时间戳\n /\n currentAt: number;\n /\n 总耗时（包括暂停时间）\n /\n elapsedTime: number;\n /\n 实际运行时间（不包括暂停时间）\n /\n runningTime: number;\n /\n 当前间隔时间\n /\n intervalTime: number;\n};\n\nexport type TimerHandler = {\n /\n 开始\n /\n start: () => void;\n /\n 暂停\n /\n pause: () => void;\n /\n 恢复\n /\n resume: (immediate?: boolean) => void;\n /\n 停止\n /\n stop: () => void;\n};\n\nconst STATUS_READY = 0;\nconst STATUS_START = 1;\nconst STATUS_PAUSE = 2;\nconst STATUS_STOP = 3;\n\n/\n 创建间隔定时器核心函数\n \n @param nextTime - 用于安排下一次执行的函数\n * @param effect - 每次执行的回调函数，接收定时器状态和可选的next函数\n * @returns 返回包含控制方法的对象\n /\nexport function makeInterval(\n nextTime: (call: () => void) => void,\n effect: (timer: TimerState, next?: () => void) => unknown,\n) {\n let startAt = 0;\n let lastAt = 0;\n let stopAt = 0;\n let pauseAt = 0;\n let resumeAt = 0;\n let times = 0;\n let status = STATUS_READY;\n let runningTime = 0;\n\n const execute = () => {\n if (status >= STATUS_PAUSE) return;\n\n const now = Date.now();\n const intervalTime = lastAt > 0 ? now - lastAt : 0;\n runningTime += intervalTime;\n lastAt = now;\n const state: TimerState = {\n times: ++times,\n startAt,\n stopAt,\n pauseAt,\n resumeAt,\n currentAt: now,\n elapsedTime: startAt > 0 ? now - startAt : 0,\n runningTime,\n intervalTime,\n };\n\n if (effect.length === 2) {\n effect(state, () => {\n nextTime(execute);\n });\n } else {\n effect(state);\n nextTime(execute);\n }\n };\n\n const canStart = () => status === STATUS_READY;\n const start = () => {\n if (!canStart()) return;\n status = STATUS_START;\n startAt = Date.now();\n execute();\n };\n\n const canStop = () => status === STATUS_START;\n const stop = () => {\n if (!canStop()) return;\n status = STATUS_STOP;\n stopAt = Date.now();\n };\n\n const canPause = () => status === STATUS_START;\n const pause = () => {\n if (!canPause()) return;\n status = STATUS_PAUSE;\n pauseAt = Date.now();\n };\n\n const canResume = () => status === STATUS_PAUSE;\n const resume = () => {\n if (!canResume()) return;\n status = STATUS_START;\n resumeAt = Date.now();\n lastAt = resumeAt;\n execute();\n };\n\n return {\n canStart,\n canStop,\n canPause,\n canResume,\n start,\n stop,\n pause,\n resume,\n execute,\n };\n}\n\nexport type TimerOptions = {\n /\n 是否在定时器开始时立即执行回调\n /\n leading?: boolean;\n /\n 是否在定时器停止时执行最后一次回调\n /\n trailing?: boolean;\n};\n\n/\n 创建一个基于 `setTimeout` 的间隔定时器\n \n @param callback - 每次间隔执行的回调函数，接收定时器状态和可选的 `next` 函数\n * @param interval - 间隔时间，单位为毫秒\n * @param options - 配置选项\n * @returns {TimerHandler}\n */\nexport function timeInterval(\n callback: (state: TimerState, next?: () => void) => unknown,\n interval: number,\n options?: TimerOptions,\n): TimerHandler {\n let timeId: number \| NodeJS.Timeout;\n const { canStart, canStop, canPause, canResume, start, stop, pause, resume, execute } = makeInterval((call) => {\n timeId = setTimeout(call, interval);\n }, callback);\n\n return {\n start() {\n if (!canStart()) return;\n\n if (options?.leading) {\n start();\n } else {\n timeId = setTimeout(start, interval);\n }\n },\n\n stop() {\n if (!canStop()) return;\n if (options?.trailing) execute();\n\n clearTimeout(timeId);\n stop();\n },\n\n pause() {\n if (!canPause()) return;\n if (options?.trailing) execute();\n\n clearTimeout(timeId);\n pause();\n },\n\n resume(immediate?: boolean) {\n if (!canResume()) return;\n\n if (immediate \|\| options?.leading) {\n resume();\n } else {\n timeId = setTimeout(resume, interval);\n }\n },\n };\n}\n"],"mappings":";AA6DA,IAAM,eAAe;AACrB,IAAM,eAAe;AACrB,IAAM,eAAe;AACrB,IAAM,cAAc;;;;;;;;AASpB,SAAgB,aACd,UACA,QACA;CACA,IAAI,UAAU;CACd,IAAI,SAAS;CACb,IAAI,SAAS;CACb,IAAI,UAAU;CACd,IAAI,WAAW;CACf,IAAI,QAAQ;CACZ,IAAI,SAAS;CACb,IAAI,cAAc;CAElB,MAAM,gBAAgB;EACpB,IAAI,UAAU,cAAc;EAE5B,MAAM,MAAM,KAAK,KAAK;EACtB,MAAM,eAAe,SAAS,IAAI,MAAM,SAAS;EACjD,eAAe;EACf,SAAS;EACT,MAAM,QAAoB;GACxB,OAAO,EAAE;GACT;GACA;GACA;GACA;GACA,WAAW;GACX,aAAa,UAAU,IAAI,MAAM,UAAU;GAC3C;GACA;GACD;EAED,IAAI,OAAO,WAAW,GACpB,OAAO,aAAa;GAClB,SAAS,QAAQ;IACjB;OACG;GACL,OAAO,MAAM;GACb,SAAS,QAAQ;;;CAIrB,MAAM,iBAAiB,WAAW;CAClC,MAAM,cAAc;EAClB,IAAI,CAAC,UAAU,EAAE;EACjB,SAAS;EACT,UAAU,KAAK,KAAK;EACpB,SAAS;;CAGX,MAAM,gBAAgB,WAAW;CACjC,MAAM,aAAa;EACjB,IAAI,CAAC,SAAS,EAAE;EAChB,SAAS;EACT,SAAS,KAAK,KAAK;;CAGrB,MAAM,iBAAiB,WAAW;CAClC,MAAM,cAAc;EAClB,IAAI,CAAC,UAAU,EAAE;EACjB,SAAS;EACT,UAAU,KAAK,KAAK;;CAGtB,MAAM,kBAAkB,WAAW;CACnC,MAAM,eAAe;EACnB,IAAI,CAAC,WAAW,EAAE;EAClB,SAAS;EACT,WAAW,KAAK,KAAK;EACrB,SAAS;EACT,SAAS;;CAGX,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;;;;;;;;;;AAsBH,SAAgB,aACd,UACA,UACA,SACc;CACd,IAAI;CACJ,MAAM,EAAE,UAAU,SAAS,UAAU,WAAW,OAAO,MAAM,OAAO,QAAQ,YAAY,cAAc,SAAS;EAC7G,SAAS,WAAW,MAAM,SAAS;IAClC,SAAS;CAEZ,OAAO;EACL,QAAQ;GACN,IAAI,CAAC,UAAU,EAAE;GAEjB,IAAI,SAAS,SACX,OAAO;QAEP,SAAS,WAAW,OAAO,SAAS;;EAIxC,OAAO;GACL,IAAI,CAAC,SAAS,EAAE;GAChB,IAAI,SAAS,UAAU,SAAS;GAEhC,aAAa,OAAO;GACpB,MAAM;;EAGR,QAAQ;GACN,IAAI,CAAC,UAAU,EAAE;GACjB,IAAI,SAAS,UAAU,SAAS;GAEhC,aAAa,OAAO;GACpB,OAAO;;EAGT,OAAO,WAAqB;GAC1B,IAAI,CAAC,WAAW,EAAE;GAElB,IAAI,aAAa,SAAS,SACxB,QAAQ;QAER,SAAS,WAAW,QAAQ,SAAS;;EAG1C"}

package/dist/tree.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"tree.cjs","names":[],"sources":["../src/tree.ts"],"sourcesContent":["import { arrayEach } from './array';\nimport { isArray, isNullish, isUndefined } from './type';\nimport type { AnyObject } from './types';\n\n/*\n 表示深度遍历中的节点对象，包含子节点列表。\n /\nexport type TreeItem = AnyObject & {\n /\n 子节点列表。\n /\n children?: TreeItem[];\n};\n\n/\n 表示深度遍历中的节点列表。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeList<I extends TreeItem> = I[];\n\n/\n 表示深度遍历中的遍历器状态。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeWalker<I extends TreeItem> = {\n /\n 当前层级的节点列表。\n /\n list: TreeList<I>;\n\n /\n 当前节点的父节点，如果为根节点则为 `null`。\n /\n parent: I \| null;\n\n /\n 当前节点的层级，从 1 开始计数。\n /\n level: number;\n\n /\n 从根节点到当前节点的路径。\n /\n path: TreeList<I>;\n};\n\n/\n 表示深度遍历中的节点信息。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeInfo<I extends TreeItem> = TreeWalker<I> & {\n /\n 当前节点。\n /\n item: I;\n\n /\n 当前节点在 `list` 中的索引。\n /\n index: number;\n};\n\n/\n 深度遍历的同步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIterator<I extends TreeItem> = (\n info: TreeInfo<I>,\n) => false \| unknown;\n\n/\n 深度遍历的异步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIteratorAsync<I extends TreeItem> = (\n info: TreeInfo<I>,\n) => Promise<boolean \| unknown>;\n\n/\n 深度遍历的同步遍历器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 遍历结果。\n /\nexport type TreeWalk<I extends TreeItem> = (walker: TreeWalker<I>) => unknown;\n\n/\n 深度遍历的异步遍历器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 异步遍历结果。\n /\nexport type TreeWalkAsync<I extends TreeItem> = (\n walker: TreeWalker<I>,\n) => Promise<unknown>;\n\n/\n 深度遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n \n @param treeList - 要遍历的深度数组。\n * @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param breadthFist - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns 无返回值。\n \n @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n treeEach(treeList, (item) => {\n * console.log(item.value);\n * if (item.value === 2) return false; // 提前终止遍历\n * });\n * ```\n /\nexport function treeEach<I extends TreeItem = TreeItem>(\n treeList: TreeList<I>,\n iterator: TreeEachIterator<I>,\n breadthFist = false,\n): void {\n const treeInfoList: TreeInfo<I>[] = [];\n let returnFalse = false;\n\n const iterate = (info: TreeInfo<I>) => {\n if (iterator(info) === false) {\n returnFalse = true;\n return false;\n }\n };\n\n const next = (info: TreeInfo<I>, walk: TreeWalk<I>) => {\n const { item, level } = info;\n const { children } = item;\n\n if (isArray(children)) {\n returnFalse =\n walk({\n ...info,\n parent: item,\n list: children as TreeList<I>,\n level: level + 1,\n }) === false;\n }\n };\n\n const walk: TreeWalk<I> = (walker) => {\n const { list, parent, path } = walker;\n\n const path2 = [...path];\n while (\n parent !== null &&\n path2.length > 0 &&\n path2[path2.length - 1] !== parent\n ) {\n path2.pop();\n }\n\n arrayEach(list, (item, index) => {\n if (returnFalse) return false;\n\n const info: TreeInfo<I> = {\n ...walker,\n item,\n index,\n path: [...path2, item],\n };\n\n // 广度优先\n if (breadthFist) {\n treeInfoList.push(info);\n }\n // 深度优先\n else {\n iterate(info);\n if (returnFalse) return false;\n next(info, walk);\n }\n });\n\n if (breadthFist) {\n while (!returnFalse) {\n const info = treeInfoList.shift();\n if (!info) break;\n\n iterate(info);\n if (returnFalse) break;\n\n // 内部也会进入 walk\n next(info, walk);\n }\n }\n\n return !returnFalse;\n };\n\n walk({\n list: treeList,\n level: 1,\n parent: null,\n path: [],\n });\n}\n\n/\n 在深度数组中查找满足条件的第一个节点信息。\n \n @param treeList - 要查找的深度数组。\n * @param predicate - 判断节点是否满足条件的回调函数。\n * @param breadthFist - 是否使用广度优先查找，默认为 `false`（深度优先）。\n * @returns 如果找到满足条件的节点，则返回该节点的信息；否则返回 `undefined`。\n \n @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n const found = treeFind(treeList, (info) => info.item.value === 3);\n * console.log(found);\n * // {\n * // item: { value: 3 },\n * // index: 1,\n * // list: [{ value: 2 }, { value: 3 }],\n * // parent: { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * // level: 2,\n * // path: [{ value: 1, children: [{ value: 2 }, { value: 3 }] }, { value: 3 }]\n * // }\n * ```\n /\nexport function treeFind<I extends TreeItem>(\n treeList: TreeList<I>,\n predicate: (info: TreeInfo<I>) => boolean,\n breadthFist = false,\n): TreeInfo<I> \| undefined {\n let found: TreeInfo<I> \| undefined;\n\n treeEach(\n treeList,\n (info) => {\n if (predicate(info)) {\n found = info;\n return false;\n }\n },\n breadthFist,\n );\n\n return found;\n}\n\n/\n 将深度嵌套的树形结构扁平化为一维数组，并对每个节点执行指定的转换函数。\n \n @template I - 树节点的类型，必须继承自 `TreeItem`。\n * @template T - 转换后的数据类型。\n * @param {TreeList<I>} deepList - 要扁平化的深度嵌套树形结构。\n * @param {(info: TreeInfo<I>) => T} flatten - 对每个节点执行的转换函数，返回转换后的数据。\n * @param {boolean} [breadthFist=false] - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns {T[]} - 转换后的一维数组。\n * @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n const flattened = deepFlat(treeList, (info) => info.item.value);\n * console.log(flattened); // [1, 2, 3, 4]\n * ```\n /\nexport function deepFlat<I extends TreeItem, T>(\n deepList: TreeList<I>,\n flatten: (info: TreeInfo<I>) => T,\n breadthFist = false,\n): T[] {\n const list2: T[] = [];\n\n treeEach(\n deepList,\n (info) => {\n list2.push(flatten(info));\n },\n breadthFist,\n );\n\n return list2;\n}\n\ntype FromItemInfo<I> = {\n selfKey: unknown;\n parentKey: unknown;\n item: I;\n index: number;\n};\n\nexport type TreeFromOptions<I extends TreeItem> = {\n getSelfKey: (item: I, index: number) => unknown;\n getParentKey: (item: I, index: number) => unknown;\n appendChild: (parentInfo: FromItemInfo<I>, info: FromItemInfo<I>) => unknown;\n};\n\n/\n 从扁平列表构建树形结构。\n \n @template I - 节点对象的类型，必须继承自 `AnyObject`。\n * @param {I[]} list - 扁平化的节点列表。\n * @param {TreeFromOptions<I>} options - 构建树形结构的配置选项。\n * @param {function} options.getSelfKey - 获取节点自身唯一标识的函数。\n * @param {function} options.getParentKey - 获取节点父节点唯一标识的函数。\n * @param {function} options.appendChild - 将子节点添加到父节点的函数。\n * @returns {I \| undefined} - 构建的树形结构的根节点，如果未找到根节点则返回 `undefined`。\n \n @example\n * ```typescript\n * const list = [\n * { id: 1, parentId: null, name: 'Root' },\n * { id: 2, parentId: 1, name: 'Child 1' },\n * { id: 3, parentId: 1, name: 'Child 2' }\n * ];\n \n const tree = treeFrom(list, {\n * getSelfKey: (item) => item.id,\n * getParentKey: (item) => item.parentId,\n * appendChild: (parent, info) => {\n * if (!parent.children) parent.children = [];\n * parent.children.push(info.item);\n * }\n * });\n \n console.log(tree);\n * // {\n * // id: 1,\n * // parentId: null,\n * // name: 'Root',\n * // children: [\n * // { id: 2, parentId: 1, name: 'Child 1' },\n * // { id: 3, parentId: 1, name: 'Child 2' }\n * // ]\n * // }\n * ```\n */\nexport function treeFrom<I extends TreeItem>(\n list: I[],\n options: TreeFromOptions<I>,\n): TreeList<I> \| undefined {\n const keyMap = new Map<unknown, FromItemInfo<I>>();\n const freeSet = new Set<FromItemInfo<I>>();\n const roots: TreeList<I> = [];\n\n // 分配节点\n const assign = (info: FromItemInfo<I>, isFirst = false) => {\n const { parentKey, item } = info;\n\n // 父级指向为空\n if (isNullish(parentKey)) {\n roots.push(item);\n }\n // 父级指向不为空\n else {\n const parent = keyMap.get(parentKey);\n\n // 未找到父级节点\n if (isUndefined(parent)) {\n // 游离节点\n if (isFirst) freeSet.add(info);\n }\n // 已找到父级节点\n else {\n options.appendChild(parent, info);\n }\n }\n };\n\n // 构建 map\n arrayEach(list, (item, index) => {\n const selfKey = options.getSelfKey(item, index);\n const parentKey = options.getParentKey(item, index);\n\n if (isNullish(selfKey)) return;\n\n const info = { selfKey, parentKey, item, index };\n keyMap.set(selfKey, info);\n\n assign(info, true);\n });\n\n // 处理游离节点\n for (const info of freeSet.values()) {\n assign(info);\n }\n\n return roots;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAgIA,SAAgB,SACd,UACA,UACA,cAAc,OACR;CACN,MAAM,eAA8B,EAAE;CACtC,IAAI,cAAc;CAElB,MAAM,WAAW,SAAsB;EACrC,IAAI,SAAS,KAAK,KAAK,OAAO;GAC5B,cAAc;GACd,OAAO;;;CAIX,MAAM,QAAQ,MAAmB,SAAsB;EACrD,MAAM,EAAE,MAAM,UAAU;EACxB,MAAM,EAAE,aAAa;EAErB,IAAI,aAAA,QAAQ,SAAS,EACnB,cACE,KAAK;GACH,GAAG;GACH,QAAQ;GACR,MAAM;GACN,OAAO,QAAQ;GAChB,CAAC,KAAK;;CAIb,MAAM,QAAqB,WAAW;EACpC,MAAM,EAAE,MAAM,QAAQ,SAAS;EAE/B,MAAM,QAAQ,CAAC,GAAG,KAAK;EACvB,OACE,WAAW,QACX,MAAM,SAAS,KACf,MAAM,MAAM,SAAS,OAAO,QAE5B,MAAM,KAAK;EAGb,cAAA,UAAU,OAAO,MAAM,UAAU;GAC/B,IAAI,aAAa,OAAO;GAExB,MAAM,OAAoB;IACxB,GAAG;IACH;IACA;IACA,MAAM,CAAC,GAAG,OAAO,KAAK;IACvB;GAGD,IAAI,aACF,aAAa,KAAK,KAAK;QAGpB;IACH,QAAQ,KAAK;IACb,IAAI,aAAa,OAAO;IACxB,KAAK,MAAM,KAAK;;IAElB;EAEF,IAAI,aACF,OAAO,CAAC,aAAa;GACnB,MAAM,OAAO,aAAa,OAAO;GACjC,IAAI,CAAC,MAAM;GAEX,QAAQ,KAAK;GACb,IAAI,aAAa;GAGjB,KAAK,MAAM,KAAK;;EAIpB,OAAO,CAAC;;CAGV,KAAK;EACH,MAAM;EACN,OAAO;EACP,QAAQ;EACR,MAAM,EAAE;EACT,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BJ,SAAgB,SACd,UACA,WACA,cAAc,OACW;CACzB,IAAI;CAEJ,SACE,WACC,SAAS;EACR,IAAI,UAAU,KAAK,EAAE;GACnB,QAAQ;GACR,OAAO;;IAGX,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;AAuBT,SAAgB,SACd,UACA,SACA,cAAc,OACT;CACL,MAAM,QAAa,EAAE;CAErB,SACE,WACC,SAAS;EACR,MAAM,KAAK,QAAQ,KAAK,CAAC;IAE3B,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDT,SAAgB,SACd,MACA,SACyB;CACzB,MAAM,yBAAS,IAAI,KAA+B;CAClD,MAAM,0BAAU,IAAI,KAAsB;CAC1C,MAAM,QAAqB,EAAE;CAG7B,MAAM,UAAU,MAAuB,UAAU,UAAU;EACzD,MAAM,EAAE,WAAW,SAAS;EAG5B,IAAI,aAAA,UAAU,UAAU,EACtB,MAAM,KAAK,KAAK;OAGb;GACH,MAAM,SAAS,OAAO,IAAI,UAAU;GAGpC,IAAI,aAAA,YAAY,OAAO;QAEjB,SAAS,QAAQ,IAAI,KAAK;UAI9B,QAAQ,YAAY,QAAQ,KAAK;;;CAMvC,cAAA,UAAU,OAAO,MAAM,UAAU;EAC/B,MAAM,UAAU,QAAQ,WAAW,MAAM,MAAM;EAC/C,MAAM,YAAY,QAAQ,aAAa,MAAM,MAAM;EAEnD,IAAI,aAAA,UAAU,QAAQ,EAAE;EAExB,MAAM,OAAO;GAAE;GAAS;GAAW;GAAM;GAAO;EAChD,OAAO,IAAI,SAAS,KAAK;EAEzB,OAAO,MAAM,KAAK;GAClB;CAGF,KAAK,MAAM,QAAQ,QAAQ,QAAQ,EACjC,OAAO,KAAK;CAGd,OAAO"}
1	+ {"version":3,"file":"tree.cjs","names":[],"sources":["../src/tree.ts"],"sourcesContent":["import { arrayEach } from './array';\nimport { isArray, isNullish, isUndefined } from './type';\nimport type { AnyObject } from './types';\n\n/*\n 表示深度遍历中的节点对象，包含子节点列表。\n /\nexport type TreeItem = AnyObject & {\n /\n 子节点列表。\n /\n children?: TreeItem[];\n};\n\n/\n 表示深度遍历中的节点列表。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeList<I extends TreeItem> = I[];\n\n/\n 表示深度遍历中的遍历器状态。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeWalker<I extends TreeItem> = {\n /\n 当前层级的节点列表。\n /\n list: TreeList<I>;\n\n /\n 当前节点的父节点，如果为根节点则为 `null`。\n /\n parent: I \| null;\n\n /\n 当前节点的层级，从 1 开始计数。\n /\n level: number;\n\n /\n 从根节点到当前节点的路径。\n /\n path: TreeList<I>;\n};\n\n/\n 表示深度遍历中的节点信息。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeInfo<I extends TreeItem> = TreeWalker<I> & {\n /\n 当前节点。\n /\n item: I;\n\n /\n 当前节点在 `list` 中的索引。\n /\n index: number;\n};\n\n/\n 深度遍历的同步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIterator<I extends TreeItem> = (info: TreeInfo<I>) => false \| unknown;\n\n/\n 深度遍历的异步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIteratorAsync<I extends TreeItem> = (info: TreeInfo<I>) => Promise<boolean \| unknown>;\n\n/\n 深度遍历的同步遍历器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 遍历结果。\n /\nexport type TreeWalk<I extends TreeItem> = (walker: TreeWalker<I>) => unknown;\n\n/\n 深度遍历的异步遍历器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 异步遍历结果。\n /\nexport type TreeWalkAsync<I extends TreeItem> = (walker: TreeWalker<I>) => Promise<unknown>;\n\n/\n 深度遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n \n @param treeList - 要遍历的深度数组。\n * @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param breadthFist - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns 无返回值。\n \n @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n treeEach(treeList, (item) => {\n * console.log(item.value);\n * if (item.value === 2) return false; // 提前终止遍历\n * });\n * ```\n /\nexport function treeEach<I extends TreeItem = TreeItem>(\n treeList: TreeList<I>,\n iterator: TreeEachIterator<I>,\n breadthFist = false,\n): void {\n const treeInfoList: TreeInfo<I>[] = [];\n let returnFalse = false;\n\n const iterate = (info: TreeInfo<I>) => {\n if (iterator(info) === false) {\n returnFalse = true;\n return false;\n }\n };\n\n const next = (info: TreeInfo<I>, walk: TreeWalk<I>) => {\n const { item, level } = info;\n const { children } = item;\n\n if (isArray(children)) {\n returnFalse =\n walk({\n ...info,\n parent: item,\n list: children as TreeList<I>,\n level: level + 1,\n }) === false;\n }\n };\n\n const walk: TreeWalk<I> = (walker) => {\n const { list, parent, path } = walker;\n\n const path2 = [...path];\n while (parent !== null && path2.length > 0 && path2[path2.length - 1] !== parent) {\n path2.pop();\n }\n\n arrayEach(list, (item, index) => {\n if (returnFalse) return false;\n\n const info: TreeInfo<I> = {\n ...walker,\n item,\n index,\n path: [...path2, item],\n };\n\n // 广度优先\n if (breadthFist) {\n treeInfoList.push(info);\n }\n // 深度优先\n else {\n iterate(info);\n if (returnFalse) return false;\n next(info, walk);\n }\n });\n\n if (breadthFist) {\n while (!returnFalse) {\n const info = treeInfoList.shift();\n if (!info) break;\n\n iterate(info);\n if (returnFalse) break;\n\n // 内部也会进入 walk\n next(info, walk);\n }\n }\n\n return !returnFalse;\n };\n\n walk({\n list: treeList,\n level: 1,\n parent: null,\n path: [],\n });\n}\n\n/\n 在深度数组中查找满足条件的第一个节点信息。\n \n @param treeList - 要查找的深度数组。\n * @param predicate - 判断节点是否满足条件的回调函数。\n * @param breadthFist - 是否使用广度优先查找，默认为 `false`（深度优先）。\n * @returns 如果找到满足条件的节点，则返回该节点的信息；否则返回 `undefined`。\n \n @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n const found = treeFind(treeList, (info) => info.item.value === 3);\n * console.log(found);\n * // {\n * // item: { value: 3 },\n * // index: 1,\n * // list: [{ value: 2 }, { value: 3 }],\n * // parent: { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * // level: 2,\n * // path: [{ value: 1, children: [{ value: 2 }, { value: 3 }] }, { value: 3 }]\n * // }\n * ```\n /\nexport function treeFind<I extends TreeItem>(\n treeList: TreeList<I>,\n predicate: (info: TreeInfo<I>) => boolean,\n breadthFist = false,\n): TreeInfo<I> \| undefined {\n let found: TreeInfo<I> \| undefined;\n\n treeEach(\n treeList,\n (info) => {\n if (predicate(info)) {\n found = info;\n return false;\n }\n },\n breadthFist,\n );\n\n return found;\n}\n\n/\n 将深度嵌套的树形结构扁平化为一维数组，并对每个节点执行指定的转换函数。\n \n @template I - 树节点的类型，必须继承自 `TreeItem`。\n * @template T - 转换后的数据类型。\n * @param {TreeList<I>} deepList - 要扁平化的深度嵌套树形结构。\n * @param {(info: TreeInfo<I>) => T} flatten - 对每个节点执行的转换函数，返回转换后的数据。\n * @param {boolean} [breadthFist=false] - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns {T[]} - 转换后的一维数组。\n * @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n const flattened = deepFlat(treeList, (info) => info.item.value);\n * console.log(flattened); // [1, 2, 3, 4]\n * ```\n /\nexport function deepFlat<I extends TreeItem, T>(\n deepList: TreeList<I>,\n flatten: (info: TreeInfo<I>) => T,\n breadthFist = false,\n): T[] {\n const list2: T[] = [];\n\n treeEach(\n deepList,\n (info) => {\n list2.push(flatten(info));\n },\n breadthFist,\n );\n\n return list2;\n}\n\ntype FromItemInfo<I> = {\n selfKey: unknown;\n parentKey: unknown;\n item: I;\n index: number;\n};\n\nexport type TreeFromOptions<I extends TreeItem> = {\n getSelfKey: (item: I, index: number) => unknown;\n getParentKey: (item: I, index: number) => unknown;\n appendChild: (parentInfo: FromItemInfo<I>, info: FromItemInfo<I>) => unknown;\n};\n\n/\n 从扁平列表构建树形结构。\n \n @template I - 节点对象的类型，必须继承自 `AnyObject`。\n * @param {I[]} list - 扁平化的节点列表。\n * @param {TreeFromOptions<I>} options - 构建树形结构的配置选项。\n * @param {function} options.getSelfKey - 获取节点自身唯一标识的函数。\n * @param {function} options.getParentKey - 获取节点父节点唯一标识的函数。\n * @param {function} options.appendChild - 将子节点添加到父节点的函数。\n * @returns {I \| undefined} - 构建的树形结构的根节点，如果未找到根节点则返回 `undefined`。\n \n @example\n * ```typescript\n * const list = [\n * { id: 1, parentId: null, name: 'Root' },\n * { id: 2, parentId: 1, name: 'Child 1' },\n * { id: 3, parentId: 1, name: 'Child 2' }\n * ];\n \n const tree = treeFrom(list, {\n * getSelfKey: (item) => item.id,\n * getParentKey: (item) => item.parentId,\n * appendChild: (parent, info) => {\n * if (!parent.children) parent.children = [];\n * parent.children.push(info.item);\n * }\n * });\n \n console.log(tree);\n * // {\n * // id: 1,\n * // parentId: null,\n * // name: 'Root',\n * // children: [\n * // { id: 2, parentId: 1, name: 'Child 1' },\n * // { id: 3, parentId: 1, name: 'Child 2' }\n * // ]\n * // }\n * ```\n */\nexport function treeFrom<I extends TreeItem>(list: I[], options: TreeFromOptions<I>): TreeList<I> \| undefined {\n const keyMap = new Map<unknown, FromItemInfo<I>>();\n const freeSet = new Set<FromItemInfo<I>>();\n const roots: TreeList<I> = [];\n\n // 分配节点\n const assign = (info: FromItemInfo<I>, isFirst = false) => {\n const { parentKey, item } = info;\n\n // 父级指向为空\n if (isNullish(parentKey)) {\n roots.push(item);\n }\n // 父级指向不为空\n else {\n const parent = keyMap.get(parentKey);\n\n // 未找到父级节点\n if (isUndefined(parent)) {\n // 游离节点\n if (isFirst) freeSet.add(info);\n }\n // 已找到父级节点\n else {\n options.appendChild(parent, info);\n }\n }\n };\n\n // 构建 map\n arrayEach(list, (item, index) => {\n const selfKey = options.getSelfKey(item, index);\n const parentKey = options.getParentKey(item, index);\n\n if (isNullish(selfKey)) return;\n\n const info = { selfKey, parentKey, item, index };\n keyMap.set(selfKey, info);\n\n assign(info, true);\n });\n\n // 处理游离节点\n for (const info of freeSet.values()) {\n assign(info);\n }\n\n return roots;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0HA,SAAgB,SACd,UACA,UACA,cAAc,OACR;CACN,MAAM,eAA8B,EAAE;CACtC,IAAI,cAAc;CAElB,MAAM,WAAW,SAAsB;EACrC,IAAI,SAAS,KAAK,KAAK,OAAO;GAC5B,cAAc;GACd,OAAO;;;CAIX,MAAM,QAAQ,MAAmB,SAAsB;EACrD,MAAM,EAAE,MAAM,UAAU;EACxB,MAAM,EAAE,aAAa;EAErB,IAAI,aAAA,QAAQ,SAAS,EACnB,cACE,KAAK;GACH,GAAG;GACH,QAAQ;GACR,MAAM;GACN,OAAO,QAAQ;GAChB,CAAC,KAAK;;CAIb,MAAM,QAAqB,WAAW;EACpC,MAAM,EAAE,MAAM,QAAQ,SAAS;EAE/B,MAAM,QAAQ,CAAC,GAAG,KAAK;EACvB,OAAO,WAAW,QAAQ,MAAM,SAAS,KAAK,MAAM,MAAM,SAAS,OAAO,QACxE,MAAM,KAAK;EAGb,cAAA,UAAU,OAAO,MAAM,UAAU;GAC/B,IAAI,aAAa,OAAO;GAExB,MAAM,OAAoB;IACxB,GAAG;IACH;IACA;IACA,MAAM,CAAC,GAAG,OAAO,KAAK;IACvB;GAGD,IAAI,aACF,aAAa,KAAK,KAAK;QAGpB;IACH,QAAQ,KAAK;IACb,IAAI,aAAa,OAAO;IACxB,KAAK,MAAM,KAAK;;IAElB;EAEF,IAAI,aACF,OAAO,CAAC,aAAa;GACnB,MAAM,OAAO,aAAa,OAAO;GACjC,IAAI,CAAC,MAAM;GAEX,QAAQ,KAAK;GACb,IAAI,aAAa;GAGjB,KAAK,MAAM,KAAK;;EAIpB,OAAO,CAAC;;CAGV,KAAK;EACH,MAAM;EACN,OAAO;EACP,QAAQ;EACR,MAAM,EAAE;EACT,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BJ,SAAgB,SACd,UACA,WACA,cAAc,OACW;CACzB,IAAI;CAEJ,SACE,WACC,SAAS;EACR,IAAI,UAAU,KAAK,EAAE;GACnB,QAAQ;GACR,OAAO;;IAGX,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;AAuBT,SAAgB,SACd,UACA,SACA,cAAc,OACT;CACL,MAAM,QAAa,EAAE;CAErB,SACE,WACC,SAAS;EACR,MAAM,KAAK,QAAQ,KAAK,CAAC;IAE3B,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDT,SAAgB,SAA6B,MAAW,SAAsD;CAC5G,MAAM,yBAAS,IAAI,KAA+B;CAClD,MAAM,0BAAU,IAAI,KAAsB;CAC1C,MAAM,QAAqB,EAAE;CAG7B,MAAM,UAAU,MAAuB,UAAU,UAAU;EACzD,MAAM,EAAE,WAAW,SAAS;EAG5B,IAAI,aAAA,UAAU,UAAU,EACtB,MAAM,KAAK,KAAK;OAGb;GACH,MAAM,SAAS,OAAO,IAAI,UAAU;GAGpC,IAAI,aAAA,YAAY,OAAO;QAEjB,SAAS,QAAQ,IAAI,KAAK;UAI9B,QAAQ,YAAY,QAAQ,KAAK;;;CAMvC,cAAA,UAAU,OAAO,MAAM,UAAU;EAC/B,MAAM,UAAU,QAAQ,WAAW,MAAM,MAAM;EAC/C,MAAM,YAAY,QAAQ,aAAa,MAAM,MAAM;EAEnD,IAAI,aAAA,UAAU,QAAQ,EAAE;EAExB,MAAM,OAAO;GAAE;GAAS;GAAW;GAAM;GAAO;EAChD,OAAO,IAAI,SAAS,KAAK;EAEzB,OAAO,MAAM,KAAK;GAClB;CAGF,KAAK,MAAM,QAAQ,QAAQ,QAAQ,EACjC,OAAO,KAAK;CAGd,OAAO"}

package/dist/tree.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"tree.mjs","names":[],"sources":["../src/tree.ts"],"sourcesContent":["import { arrayEach } from './array';\nimport { isArray, isNullish, isUndefined } from './type';\nimport type { AnyObject } from './types';\n\n/*\n 表示深度遍历中的节点对象，包含子节点列表。\n /\nexport type TreeItem = AnyObject & {\n /\n 子节点列表。\n /\n children?: TreeItem[];\n};\n\n/\n 表示深度遍历中的节点列表。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeList<I extends TreeItem> = I[];\n\n/\n 表示深度遍历中的遍历器状态。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeWalker<I extends TreeItem> = {\n /\n 当前层级的节点列表。\n /\n list: TreeList<I>;\n\n /\n 当前节点的父节点，如果为根节点则为 `null`。\n /\n parent: I \| null;\n\n /\n 当前节点的层级，从 1 开始计数。\n /\n level: number;\n\n /\n 从根节点到当前节点的路径。\n /\n path: TreeList<I>;\n};\n\n/\n 表示深度遍历中的节点信息。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeInfo<I extends TreeItem> = TreeWalker<I> & {\n /\n 当前节点。\n /\n item: I;\n\n /\n 当前节点在 `list` 中的索引。\n /\n index: number;\n};\n\n/\n 深度遍历的同步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIterator<I extends TreeItem> = (\n info: TreeInfo<I>,\n) => false \| unknown;\n\n/\n 深度遍历的异步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIteratorAsync<I extends TreeItem> = (\n info: TreeInfo<I>,\n) => Promise<boolean \| unknown>;\n\n/\n 深度遍历的同步遍历器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 遍历结果。\n /\nexport type TreeWalk<I extends TreeItem> = (walker: TreeWalker<I>) => unknown;\n\n/\n 深度遍历的异步遍历器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 异步遍历结果。\n /\nexport type TreeWalkAsync<I extends TreeItem> = (\n walker: TreeWalker<I>,\n) => Promise<unknown>;\n\n/\n 深度遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n \n @param treeList - 要遍历的深度数组。\n * @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param breadthFist - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns 无返回值。\n \n @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n treeEach(treeList, (item) => {\n * console.log(item.value);\n * if (item.value === 2) return false; // 提前终止遍历\n * });\n * ```\n /\nexport function treeEach<I extends TreeItem = TreeItem>(\n treeList: TreeList<I>,\n iterator: TreeEachIterator<I>,\n breadthFist = false,\n): void {\n const treeInfoList: TreeInfo<I>[] = [];\n let returnFalse = false;\n\n const iterate = (info: TreeInfo<I>) => {\n if (iterator(info) === false) {\n returnFalse = true;\n return false;\n }\n };\n\n const next = (info: TreeInfo<I>, walk: TreeWalk<I>) => {\n const { item, level } = info;\n const { children } = item;\n\n if (isArray(children)) {\n returnFalse =\n walk({\n ...info,\n parent: item,\n list: children as TreeList<I>,\n level: level + 1,\n }) === false;\n }\n };\n\n const walk: TreeWalk<I> = (walker) => {\n const { list, parent, path } = walker;\n\n const path2 = [...path];\n while (\n parent !== null &&\n path2.length > 0 &&\n path2[path2.length - 1] !== parent\n ) {\n path2.pop();\n }\n\n arrayEach(list, (item, index) => {\n if (returnFalse) return false;\n\n const info: TreeInfo<I> = {\n ...walker,\n item,\n index,\n path: [...path2, item],\n };\n\n // 广度优先\n if (breadthFist) {\n treeInfoList.push(info);\n }\n // 深度优先\n else {\n iterate(info);\n if (returnFalse) return false;\n next(info, walk);\n }\n });\n\n if (breadthFist) {\n while (!returnFalse) {\n const info = treeInfoList.shift();\n if (!info) break;\n\n iterate(info);\n if (returnFalse) break;\n\n // 内部也会进入 walk\n next(info, walk);\n }\n }\n\n return !returnFalse;\n };\n\n walk({\n list: treeList,\n level: 1,\n parent: null,\n path: [],\n });\n}\n\n/\n 在深度数组中查找满足条件的第一个节点信息。\n \n @param treeList - 要查找的深度数组。\n * @param predicate - 判断节点是否满足条件的回调函数。\n * @param breadthFist - 是否使用广度优先查找，默认为 `false`（深度优先）。\n * @returns 如果找到满足条件的节点，则返回该节点的信息；否则返回 `undefined`。\n \n @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n const found = treeFind(treeList, (info) => info.item.value === 3);\n * console.log(found);\n * // {\n * // item: { value: 3 },\n * // index: 1,\n * // list: [{ value: 2 }, { value: 3 }],\n * // parent: { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * // level: 2,\n * // path: [{ value: 1, children: [{ value: 2 }, { value: 3 }] }, { value: 3 }]\n * // }\n * ```\n /\nexport function treeFind<I extends TreeItem>(\n treeList: TreeList<I>,\n predicate: (info: TreeInfo<I>) => boolean,\n breadthFist = false,\n): TreeInfo<I> \| undefined {\n let found: TreeInfo<I> \| undefined;\n\n treeEach(\n treeList,\n (info) => {\n if (predicate(info)) {\n found = info;\n return false;\n }\n },\n breadthFist,\n );\n\n return found;\n}\n\n/\n 将深度嵌套的树形结构扁平化为一维数组，并对每个节点执行指定的转换函数。\n \n @template I - 树节点的类型，必须继承自 `TreeItem`。\n * @template T - 转换后的数据类型。\n * @param {TreeList<I>} deepList - 要扁平化的深度嵌套树形结构。\n * @param {(info: TreeInfo<I>) => T} flatten - 对每个节点执行的转换函数，返回转换后的数据。\n * @param {boolean} [breadthFist=false] - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns {T[]} - 转换后的一维数组。\n * @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n const flattened = deepFlat(treeList, (info) => info.item.value);\n * console.log(flattened); // [1, 2, 3, 4]\n * ```\n /\nexport function deepFlat<I extends TreeItem, T>(\n deepList: TreeList<I>,\n flatten: (info: TreeInfo<I>) => T,\n breadthFist = false,\n): T[] {\n const list2: T[] = [];\n\n treeEach(\n deepList,\n (info) => {\n list2.push(flatten(info));\n },\n breadthFist,\n );\n\n return list2;\n}\n\ntype FromItemInfo<I> = {\n selfKey: unknown;\n parentKey: unknown;\n item: I;\n index: number;\n};\n\nexport type TreeFromOptions<I extends TreeItem> = {\n getSelfKey: (item: I, index: number) => unknown;\n getParentKey: (item: I, index: number) => unknown;\n appendChild: (parentInfo: FromItemInfo<I>, info: FromItemInfo<I>) => unknown;\n};\n\n/\n 从扁平列表构建树形结构。\n \n @template I - 节点对象的类型，必须继承自 `AnyObject`。\n * @param {I[]} list - 扁平化的节点列表。\n * @param {TreeFromOptions<I>} options - 构建树形结构的配置选项。\n * @param {function} options.getSelfKey - 获取节点自身唯一标识的函数。\n * @param {function} options.getParentKey - 获取节点父节点唯一标识的函数。\n * @param {function} options.appendChild - 将子节点添加到父节点的函数。\n * @returns {I \| undefined} - 构建的树形结构的根节点，如果未找到根节点则返回 `undefined`。\n \n @example\n * ```typescript\n * const list = [\n * { id: 1, parentId: null, name: 'Root' },\n * { id: 2, parentId: 1, name: 'Child 1' },\n * { id: 3, parentId: 1, name: 'Child 2' }\n * ];\n \n const tree = treeFrom(list, {\n * getSelfKey: (item) => item.id,\n * getParentKey: (item) => item.parentId,\n * appendChild: (parent, info) => {\n * if (!parent.children) parent.children = [];\n * parent.children.push(info.item);\n * }\n * });\n \n console.log(tree);\n * // {\n * // id: 1,\n * // parentId: null,\n * // name: 'Root',\n * // children: [\n * // { id: 2, parentId: 1, name: 'Child 1' },\n * // { id: 3, parentId: 1, name: 'Child 2' }\n * // ]\n * // }\n * ```\n */\nexport function treeFrom<I extends TreeItem>(\n list: I[],\n options: TreeFromOptions<I>,\n): TreeList<I> \| undefined {\n const keyMap = new Map<unknown, FromItemInfo<I>>();\n const freeSet = new Set<FromItemInfo<I>>();\n const roots: TreeList<I> = [];\n\n // 分配节点\n const assign = (info: FromItemInfo<I>, isFirst = false) => {\n const { parentKey, item } = info;\n\n // 父级指向为空\n if (isNullish(parentKey)) {\n roots.push(item);\n }\n // 父级指向不为空\n else {\n const parent = keyMap.get(parentKey);\n\n // 未找到父级节点\n if (isUndefined(parent)) {\n // 游离节点\n if (isFirst) freeSet.add(info);\n }\n // 已找到父级节点\n else {\n options.appendChild(parent, info);\n }\n }\n };\n\n // 构建 map\n arrayEach(list, (item, index) => {\n const selfKey = options.getSelfKey(item, index);\n const parentKey = options.getParentKey(item, index);\n\n if (isNullish(selfKey)) return;\n\n const info = { selfKey, parentKey, item, index };\n keyMap.set(selfKey, info);\n\n assign(info, true);\n });\n\n // 处理游离节点\n for (const info of freeSet.values()) {\n assign(info);\n }\n\n return roots;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAgIA,SAAgB,SACd,UACA,UACA,cAAc,OACR;CACN,MAAM,eAA8B,EAAE;CACtC,IAAI,cAAc;CAElB,MAAM,WAAW,SAAsB;EACrC,IAAI,SAAS,KAAK,KAAK,OAAO;GAC5B,cAAc;GACd,OAAO;;;CAIX,MAAM,QAAQ,MAAmB,SAAsB;EACrD,MAAM,EAAE,MAAM,UAAU;EACxB,MAAM,EAAE,aAAa;EAErB,IAAI,QAAQ,SAAS,EACnB,cACE,KAAK;GACH,GAAG;GACH,QAAQ;GACR,MAAM;GACN,OAAO,QAAQ;GAChB,CAAC,KAAK;;CAIb,MAAM,QAAqB,WAAW;EACpC,MAAM,EAAE,MAAM,QAAQ,SAAS;EAE/B,MAAM,QAAQ,CAAC,GAAG,KAAK;EACvB,OACE,WAAW,QACX,MAAM,SAAS,KACf,MAAM,MAAM,SAAS,OAAO,QAE5B,MAAM,KAAK;EAGb,UAAU,OAAO,MAAM,UAAU;GAC/B,IAAI,aAAa,OAAO;GAExB,MAAM,OAAoB;IACxB,GAAG;IACH;IACA;IACA,MAAM,CAAC,GAAG,OAAO,KAAK;IACvB;GAGD,IAAI,aACF,aAAa,KAAK,KAAK;QAGpB;IACH,QAAQ,KAAK;IACb,IAAI,aAAa,OAAO;IACxB,KAAK,MAAM,KAAK;;IAElB;EAEF,IAAI,aACF,OAAO,CAAC,aAAa;GACnB,MAAM,OAAO,aAAa,OAAO;GACjC,IAAI,CAAC,MAAM;GAEX,QAAQ,KAAK;GACb,IAAI,aAAa;GAGjB,KAAK,MAAM,KAAK;;EAIpB,OAAO,CAAC;;CAGV,KAAK;EACH,MAAM;EACN,OAAO;EACP,QAAQ;EACR,MAAM,EAAE;EACT,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BJ,SAAgB,SACd,UACA,WACA,cAAc,OACW;CACzB,IAAI;CAEJ,SACE,WACC,SAAS;EACR,IAAI,UAAU,KAAK,EAAE;GACnB,QAAQ;GACR,OAAO;;IAGX,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;AAuBT,SAAgB,SACd,UACA,SACA,cAAc,OACT;CACL,MAAM,QAAa,EAAE;CAErB,SACE,WACC,SAAS;EACR,MAAM,KAAK,QAAQ,KAAK,CAAC;IAE3B,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDT,SAAgB,SACd,MACA,SACyB;CACzB,MAAM,yBAAS,IAAI,KAA+B;CAClD,MAAM,0BAAU,IAAI,KAAsB;CAC1C,MAAM,QAAqB,EAAE;CAG7B,MAAM,UAAU,MAAuB,UAAU,UAAU;EACzD,MAAM,EAAE,WAAW,SAAS;EAG5B,IAAI,UAAU,UAAU,EACtB,MAAM,KAAK,KAAK;OAGb;GACH,MAAM,SAAS,OAAO,IAAI,UAAU;GAGpC,IAAI,YAAY,OAAO;QAEjB,SAAS,QAAQ,IAAI,KAAK;UAI9B,QAAQ,YAAY,QAAQ,KAAK;;;CAMvC,UAAU,OAAO,MAAM,UAAU;EAC/B,MAAM,UAAU,QAAQ,WAAW,MAAM,MAAM;EAC/C,MAAM,YAAY,QAAQ,aAAa,MAAM,MAAM;EAEnD,IAAI,UAAU,QAAQ,EAAE;EAExB,MAAM,OAAO;GAAE;GAAS;GAAW;GAAM;GAAO;EAChD,OAAO,IAAI,SAAS,KAAK;EAEzB,OAAO,MAAM,KAAK;GAClB;CAGF,KAAK,MAAM,QAAQ,QAAQ,QAAQ,EACjC,OAAO,KAAK;CAGd,OAAO"}
1	+ {"version":3,"file":"tree.mjs","names":[],"sources":["../src/tree.ts"],"sourcesContent":["import { arrayEach } from './array';\nimport { isArray, isNullish, isUndefined } from './type';\nimport type { AnyObject } from './types';\n\n/*\n 表示深度遍历中的节点对象，包含子节点列表。\n /\nexport type TreeItem = AnyObject & {\n /\n 子节点列表。\n /\n children?: TreeItem[];\n};\n\n/\n 表示深度遍历中的节点列表。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeList<I extends TreeItem> = I[];\n\n/\n 表示深度遍历中的遍历器状态。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeWalker<I extends TreeItem> = {\n /\n 当前层级的节点列表。\n /\n list: TreeList<I>;\n\n /\n 当前节点的父节点，如果为根节点则为 `null`。\n /\n parent: I \| null;\n\n /\n 当前节点的层级，从 1 开始计数。\n /\n level: number;\n\n /\n 从根节点到当前节点的路径。\n /\n path: TreeList<I>;\n};\n\n/\n 表示深度遍历中的节点信息。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n /\nexport type TreeInfo<I extends TreeItem> = TreeWalker<I> & {\n /\n 当前节点。\n /\n item: I;\n\n /\n 当前节点在 `list` 中的索引。\n /\n index: number;\n};\n\n/\n 深度遍历的同步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIterator<I extends TreeItem> = (info: TreeInfo<I>) => false \| unknown;\n\n/\n 深度遍历的异步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIteratorAsync<I extends TreeItem> = (info: TreeInfo<I>) => Promise<boolean \| unknown>;\n\n/\n 深度遍历的同步遍历器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 遍历结果。\n /\nexport type TreeWalk<I extends TreeItem> = (walker: TreeWalker<I>) => unknown;\n\n/\n 深度遍历的异步遍历器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 异步遍历结果。\n /\nexport type TreeWalkAsync<I extends TreeItem> = (walker: TreeWalker<I>) => Promise<unknown>;\n\n/\n 深度遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n \n @param treeList - 要遍历的深度数组。\n * @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param breadthFist - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns 无返回值。\n \n @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n treeEach(treeList, (item) => {\n * console.log(item.value);\n * if (item.value === 2) return false; // 提前终止遍历\n * });\n * ```\n /\nexport function treeEach<I extends TreeItem = TreeItem>(\n treeList: TreeList<I>,\n iterator: TreeEachIterator<I>,\n breadthFist = false,\n): void {\n const treeInfoList: TreeInfo<I>[] = [];\n let returnFalse = false;\n\n const iterate = (info: TreeInfo<I>) => {\n if (iterator(info) === false) {\n returnFalse = true;\n return false;\n }\n };\n\n const next = (info: TreeInfo<I>, walk: TreeWalk<I>) => {\n const { item, level } = info;\n const { children } = item;\n\n if (isArray(children)) {\n returnFalse =\n walk({\n ...info,\n parent: item,\n list: children as TreeList<I>,\n level: level + 1,\n }) === false;\n }\n };\n\n const walk: TreeWalk<I> = (walker) => {\n const { list, parent, path } = walker;\n\n const path2 = [...path];\n while (parent !== null && path2.length > 0 && path2[path2.length - 1] !== parent) {\n path2.pop();\n }\n\n arrayEach(list, (item, index) => {\n if (returnFalse) return false;\n\n const info: TreeInfo<I> = {\n ...walker,\n item,\n index,\n path: [...path2, item],\n };\n\n // 广度优先\n if (breadthFist) {\n treeInfoList.push(info);\n }\n // 深度优先\n else {\n iterate(info);\n if (returnFalse) return false;\n next(info, walk);\n }\n });\n\n if (breadthFist) {\n while (!returnFalse) {\n const info = treeInfoList.shift();\n if (!info) break;\n\n iterate(info);\n if (returnFalse) break;\n\n // 内部也会进入 walk\n next(info, walk);\n }\n }\n\n return !returnFalse;\n };\n\n walk({\n list: treeList,\n level: 1,\n parent: null,\n path: [],\n });\n}\n\n/\n 在深度数组中查找满足条件的第一个节点信息。\n \n @param treeList - 要查找的深度数组。\n * @param predicate - 判断节点是否满足条件的回调函数。\n * @param breadthFist - 是否使用广度优先查找，默认为 `false`（深度优先）。\n * @returns 如果找到满足条件的节点，则返回该节点的信息；否则返回 `undefined`。\n \n @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n const found = treeFind(treeList, (info) => info.item.value === 3);\n * console.log(found);\n * // {\n * // item: { value: 3 },\n * // index: 1,\n * // list: [{ value: 2 }, { value: 3 }],\n * // parent: { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * // level: 2,\n * // path: [{ value: 1, children: [{ value: 2 }, { value: 3 }] }, { value: 3 }]\n * // }\n * ```\n /\nexport function treeFind<I extends TreeItem>(\n treeList: TreeList<I>,\n predicate: (info: TreeInfo<I>) => boolean,\n breadthFist = false,\n): TreeInfo<I> \| undefined {\n let found: TreeInfo<I> \| undefined;\n\n treeEach(\n treeList,\n (info) => {\n if (predicate(info)) {\n found = info;\n return false;\n }\n },\n breadthFist,\n );\n\n return found;\n}\n\n/\n 将深度嵌套的树形结构扁平化为一维数组，并对每个节点执行指定的转换函数。\n \n @template I - 树节点的类型，必须继承自 `TreeItem`。\n * @template T - 转换后的数据类型。\n * @param {TreeList<I>} deepList - 要扁平化的深度嵌套树形结构。\n * @param {(info: TreeInfo<I>) => T} flatten - 对每个节点执行的转换函数，返回转换后的数据。\n * @param {boolean} [breadthFist=false] - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns {T[]} - 转换后的一维数组。\n * @example\n * ```typescript\n * const treeList = [\n * { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * { value: 4 }\n * ];\n \n const flattened = deepFlat(treeList, (info) => info.item.value);\n * console.log(flattened); // [1, 2, 3, 4]\n * ```\n /\nexport function deepFlat<I extends TreeItem, T>(\n deepList: TreeList<I>,\n flatten: (info: TreeInfo<I>) => T,\n breadthFist = false,\n): T[] {\n const list2: T[] = [];\n\n treeEach(\n deepList,\n (info) => {\n list2.push(flatten(info));\n },\n breadthFist,\n );\n\n return list2;\n}\n\ntype FromItemInfo<I> = {\n selfKey: unknown;\n parentKey: unknown;\n item: I;\n index: number;\n};\n\nexport type TreeFromOptions<I extends TreeItem> = {\n getSelfKey: (item: I, index: number) => unknown;\n getParentKey: (item: I, index: number) => unknown;\n appendChild: (parentInfo: FromItemInfo<I>, info: FromItemInfo<I>) => unknown;\n};\n\n/\n 从扁平列表构建树形结构。\n \n @template I - 节点对象的类型，必须继承自 `AnyObject`。\n * @param {I[]} list - 扁平化的节点列表。\n * @param {TreeFromOptions<I>} options - 构建树形结构的配置选项。\n * @param {function} options.getSelfKey - 获取节点自身唯一标识的函数。\n * @param {function} options.getParentKey - 获取节点父节点唯一标识的函数。\n * @param {function} options.appendChild - 将子节点添加到父节点的函数。\n * @returns {I \| undefined} - 构建的树形结构的根节点，如果未找到根节点则返回 `undefined`。\n \n @example\n * ```typescript\n * const list = [\n * { id: 1, parentId: null, name: 'Root' },\n * { id: 2, parentId: 1, name: 'Child 1' },\n * { id: 3, parentId: 1, name: 'Child 2' }\n * ];\n \n const tree = treeFrom(list, {\n * getSelfKey: (item) => item.id,\n * getParentKey: (item) => item.parentId,\n * appendChild: (parent, info) => {\n * if (!parent.children) parent.children = [];\n * parent.children.push(info.item);\n * }\n * });\n \n console.log(tree);\n * // {\n * // id: 1,\n * // parentId: null,\n * // name: 'Root',\n * // children: [\n * // { id: 2, parentId: 1, name: 'Child 1' },\n * // { id: 3, parentId: 1, name: 'Child 2' }\n * // ]\n * // }\n * ```\n */\nexport function treeFrom<I extends TreeItem>(list: I[], options: TreeFromOptions<I>): TreeList<I> \| undefined {\n const keyMap = new Map<unknown, FromItemInfo<I>>();\n const freeSet = new Set<FromItemInfo<I>>();\n const roots: TreeList<I> = [];\n\n // 分配节点\n const assign = (info: FromItemInfo<I>, isFirst = false) => {\n const { parentKey, item } = info;\n\n // 父级指向为空\n if (isNullish(parentKey)) {\n roots.push(item);\n }\n // 父级指向不为空\n else {\n const parent = keyMap.get(parentKey);\n\n // 未找到父级节点\n if (isUndefined(parent)) {\n // 游离节点\n if (isFirst) freeSet.add(info);\n }\n // 已找到父级节点\n else {\n options.appendChild(parent, info);\n }\n }\n };\n\n // 构建 map\n arrayEach(list, (item, index) => {\n const selfKey = options.getSelfKey(item, index);\n const parentKey = options.getParentKey(item, index);\n\n if (isNullish(selfKey)) return;\n\n const info = { selfKey, parentKey, item, index };\n keyMap.set(selfKey, info);\n\n assign(info, true);\n });\n\n // 处理游离节点\n for (const info of freeSet.values()) {\n assign(info);\n }\n\n return roots;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA0HA,SAAgB,SACd,UACA,UACA,cAAc,OACR;CACN,MAAM,eAA8B,EAAE;CACtC,IAAI,cAAc;CAElB,MAAM,WAAW,SAAsB;EACrC,IAAI,SAAS,KAAK,KAAK,OAAO;GAC5B,cAAc;GACd,OAAO;;;CAIX,MAAM,QAAQ,MAAmB,SAAsB;EACrD,MAAM,EAAE,MAAM,UAAU;EACxB,MAAM,EAAE,aAAa;EAErB,IAAI,QAAQ,SAAS,EACnB,cACE,KAAK;GACH,GAAG;GACH,QAAQ;GACR,MAAM;GACN,OAAO,QAAQ;GAChB,CAAC,KAAK;;CAIb,MAAM,QAAqB,WAAW;EACpC,MAAM,EAAE,MAAM,QAAQ,SAAS;EAE/B,MAAM,QAAQ,CAAC,GAAG,KAAK;EACvB,OAAO,WAAW,QAAQ,MAAM,SAAS,KAAK,MAAM,MAAM,SAAS,OAAO,QACxE,MAAM,KAAK;EAGb,UAAU,OAAO,MAAM,UAAU;GAC/B,IAAI,aAAa,OAAO;GAExB,MAAM,OAAoB;IACxB,GAAG;IACH;IACA;IACA,MAAM,CAAC,GAAG,OAAO,KAAK;IACvB;GAGD,IAAI,aACF,aAAa,KAAK,KAAK;QAGpB;IACH,QAAQ,KAAK;IACb,IAAI,aAAa,OAAO;IACxB,KAAK,MAAM,KAAK;;IAElB;EAEF,IAAI,aACF,OAAO,CAAC,aAAa;GACnB,MAAM,OAAO,aAAa,OAAO;GACjC,IAAI,CAAC,MAAM;GAEX,QAAQ,KAAK;GACb,IAAI,aAAa;GAGjB,KAAK,MAAM,KAAK;;EAIpB,OAAO,CAAC;;CAGV,KAAK;EACH,MAAM;EACN,OAAO;EACP,QAAQ;EACR,MAAM,EAAE;EACT,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BJ,SAAgB,SACd,UACA,WACA,cAAc,OACW;CACzB,IAAI;CAEJ,SACE,WACC,SAAS;EACR,IAAI,UAAU,KAAK,EAAE;GACnB,QAAQ;GACR,OAAO;;IAGX,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;AAuBT,SAAgB,SACd,UACA,SACA,cAAc,OACT;CACL,MAAM,QAAa,EAAE;CAErB,SACE,WACC,SAAS;EACR,MAAM,KAAK,QAAQ,KAAK,CAAC;IAE3B,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDT,SAAgB,SAA6B,MAAW,SAAsD;CAC5G,MAAM,yBAAS,IAAI,KAA+B;CAClD,MAAM,0BAAU,IAAI,KAAsB;CAC1C,MAAM,QAAqB,EAAE;CAG7B,MAAM,UAAU,MAAuB,UAAU,UAAU;EACzD,MAAM,EAAE,WAAW,SAAS;EAG5B,IAAI,UAAU,UAAU,EACtB,MAAM,KAAK,KAAK;OAGb;GACH,MAAM,SAAS,OAAO,IAAI,UAAU;GAGpC,IAAI,YAAY,OAAO;QAEjB,SAAS,QAAQ,IAAI,KAAK;UAI9B,QAAQ,YAAY,QAAQ,KAAK;;;CAMvC,UAAU,OAAO,MAAM,UAAU;EAC/B,MAAM,UAAU,QAAQ,WAAW,MAAM,MAAM;EAC/C,MAAM,YAAY,QAAQ,aAAa,MAAM,MAAM;EAEnD,IAAI,UAAU,QAAQ,EAAE;EAExB,MAAM,OAAO;GAAE;GAAS;GAAW;GAAM;GAAO;EAChD,OAAO,IAAI,SAAS,KAAK;EAEzB,OAAO,MAAM,KAAK;GAClB;CAGF,KAAK,MAAM,QAAQ,QAAQ,QAAQ,EACjC,OAAO,KAAK;CAGd,OAAO"}