@tendaui/components 1.0.0 → 1.0.2

package/utils/input-number/large-number.ts

@@ -0,0 +1,423 @@
+import { isString, isNumber, isObject } from "lodash-es";
+import log from "../log/log";
+
+export type InputNumberDecimalPlaces = number | { enableRound: boolean; places: number };
+
+export function fillZero(length: number) {
+  return new Array(length).fill(0).join("");
+}
+
+/**
+ * 大数，是否是一个数字，数字字符包括 - . e [0-9]
+ */
+export function isInputNumber(num: number | string): boolean {
+  if (!num) return true;
+  if (isNumber(num)) return !Number.isNaN(num);
+  const r = /^[0-9|e|E|-]+\.*[0-9|e|E|-]*$/.test(num);
+  if (!r) return false;
+  // only allow one [.e] and two [-]
+  let eCount = 0;
+  let negativeCount = 0;
+  let dotCount = 0;
+  for (let i = 0, len = num.length; i < len; i++) {
+    if (num[i] === ".") {
+      dotCount += 1;
+      if (dotCount > 1) return false;
+    }
+    if (/(e|E)+/.test(num[i])) {
+      eCount += 1;
+      if (eCount > 1) return false;
+    }
+    if (num[i] === "-") {
+      negativeCount += 1;
+      if (negativeCount > 2) return false;
+    }
+  }
+  return true;
+}
+
+// 整数，去除前面的无效 0（本身是 0 除外）；小数去除末尾的无效 0
+export function removeInvalidZero(num: string, decimal = false) {
+  if (num.indexOf(".") !== -1) {
+    log.error("InputNumber", "num is not a integer number.");
+    return num;
+  }
+  if (!num || (num === "0" && decimal)) return "";
+  if (num === "0") return num;
+  return (decimal ? num.replace(/0+$/, "") : num.replace(/^0+/, "")) || "0";
+}
+
+/**
+ * 大数加法，仅支持正整数（没有精度问题）
+ * @param num1 被加数
+ * @param num2 加数
+ */
+export function largeIntNumberAdd(num1: string, num2: string, decimal = false): string {
+  const number1 = removeInvalidZero(num1, decimal);
+  const number2 = removeInvalidZero(num2, decimal);
+  const isFirstLarger = number1.length > number2.length;
+  const maxNumber = isFirstLarger ? number1 : number2;
+  const minNumber = isFirstLarger ? number2 : number1;
+  const newNumber: string[] = [];
+  const step = [];
+  const diff = decimal ? 0 : maxNumber.length - minNumber.length;
+  const len = decimal ? minNumber.length : maxNumber.length;
+  for (let i = len - 1; i >= 0; i--) {
+    const minIndex = i - diff;
+    // 第一个数，加第二个数，加进位
+    const count = Number(maxNumber[i]) + (Number(minNumber[minIndex]) || 0) + (step[i] || 0);
+    if (count >= 10) {
+      step[i - 1] = 1;
+    }
+    newNumber.unshift(String(count % 10));
+  }
+  // 999 + 1 = 1000，之类的进位
+  if (step[-1]) {
+    newNumber.unshift("1");
+  }
+  if (decimal) {
+    return newNumber.concat(maxNumber.slice(len, maxNumber.length)).join("");
+  }
+  return newNumber.join("");
+}
+
+/**
+ * 大数加法，支持小数和整数（没有精度问题）
+ * @param num1 被加数
+ * @param num2 加数
+ */
+export function largePositiveNumberAdd(num1: string, num2: string): string {
+  const [intNumber1 = "0", decimalNumber1 = "0"] = num1.split(".");
+  const [intNumber2 = "0", decimalNumber2 = "0"] = num2.split(".");
+  const integerSum = largeIntNumberAdd(intNumber1, intNumber2);
+  // 如果不存在小数，则直接返回整数相加结果
+  if (decimalNumber1 === "0" && decimalNumber2 === "0") return integerSum;
+  const newDecimalNumber1 = removeInvalidZero(decimalNumber1, true);
+  const newDecimalNumber2 = removeInvalidZero(decimalNumber2, true);
+  // 小数点相加
+  const decimalNumberSum = largeIntNumberAdd(newDecimalNumber1, newDecimalNumber2, true);
+  // 组合整数部分和小数部分
+  const decimalLength = decimalNumberSum.length;
+  // 如果小数相加进位
+  if (decimalLength > newDecimalNumber1.length && decimalLength > newDecimalNumber2.length) {
+    return [removeInvalidZero(largeIntNumberAdd(integerSum, "1")), removeInvalidZero(decimalNumberSum.slice(1), true)]
+      .filter((v: string) => v)
+      .join(".");
+  }
+  return [removeInvalidZero(integerSum), removeInvalidZero(decimalNumberSum, true)].filter((v: string) => v).join(".");
+}
+
+/**
+ * 比较两个大数的大小，仅正整数有效
+ */
+function compareLargeIntegerNumber(num1: string, num2: string): 1 | -1 | 0 {
+  const number1 = removeInvalidZero(num1);
+  const number2 = removeInvalidZero(num2);
+  if (number1.length === number2.length) {
+    for (let i = 0, len = number1.length; i < len; i++) {
+      if (number1[i] > number2[i]) return 1;
+      if (number1[i] < number2[i]) return -1;
+    }
+    return 0;
+  }
+  return number1.length > number2.length ? 1 : -1;
+}
+
+function compareLargeDecimalNumber(num1: string, num2: string) {
+  const number1 = num1 && num1 !== "0" ? num1.replace(/0+$/, "") : "0";
+  const number2 = num2 && num2 !== "0" ? num2.replace(/0+$/, "") : "0";
+  const maxLength = Math.max(number1.length, number2.length);
+  for (let i = 0, len = maxLength; i < len; i++) {
+    if ((number1[i] || 0) > (number2[i] || 0)) return 1;
+    if ((number1[i] || 0) < (number2[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+/**
+ * 2e3 => 2000
+ * 0.2e3 => 200
+ */
+export function formatENumber(num: string): string {
+  const [num1, num2] = num.split("e");
+  if (!num2) return num;
+  const [integer, initDecimal = ""] = num.split(".");
+  const zeroCount = Number(num2);
+  const [decimal] = initDecimal.split("e");
+  if (zeroCount > decimal.length) {
+    const multipleZero = fillZero(zeroCount - decimal.length);
+    return num1.replace(/(^0+|\.)/g, "") + multipleZero;
+  }
+  const n1 = integer.replace(/^0+/, "") + decimal.slice(0, zeroCount);
+  const d2 = decimal.slice(zeroCount);
+  return d2 ? [n1, d2].join(".") : n1;
+}
+
+/**
+ * 比较两个大数的大小
+ */
+export function compareLargeNumber(num1: string, num2: string): 1 | -1 | 0 {
+  const [integer1, decimal1] = formatENumber(num1).split(".");
+  const [integer2, decimal2] = formatENumber(num2).split(".");
+  const result = compareLargeIntegerNumber(integer1.replace("-", ""), integer2.replace("-", ""));
+  const integer1IsNegative = integer1.includes("-");
+  const integer2IsNegative = integer2.includes("-");
+  if (integer1IsNegative && !integer2IsNegative) return -1;
+  if (!integer1IsNegative && integer2IsNegative) return 1;
+  if (integer1IsNegative && integer2IsNegative) {
+    if (result === 0) return 0;
+    return result > 0 ? -1 : 1;
+  }
+  if (result === 0) {
+    return compareLargeDecimalNumber(decimal1, decimal2);
+  }
+  return result;
+}
+
+// 确认是否为无限大/小
+export function isInfinity(num: number | string) {
+  return [-Infinity, Infinity].includes(Number(num));
+}
+
+// 确认是否是大数
+export function isSafeNumber(num: string | number) {
+  return Number(num) < Number.MAX_SAFE_INTEGER && Number(num) > Number.MIN_SAFE_INTEGER;
+}
+
+/**
+ * 比较两个数的大小
+ */
+export function compareNumber(num1: string | number, num2: string | number, largeNumber?: boolean) {
+  const isSafeNumberCompare = isSafeNumber(num1) && isSafeNumber(num2) && !largeNumber;
+  const isInfinityCompare = isInfinity(num1) || isInfinity(num2);
+  if (isSafeNumberCompare || isInfinityCompare) {
+    // 比较两个非大数或涉及无穷的大小
+    if (Number(num1) === Number(num2)) return 0;
+    return Number(num1) > Number(num2) ? 1 : -1;
+  }
+  // 比较两个大数的大小
+  return compareLargeNumber(String(num1), String(num2));
+}
+
+/**
+ * 大数减法，仅支持整数
+ * @param num1 被减数
+ * @param num2 减数
+ * @param decimal 是否为小数位相减
+ */
+export function largeIntegerNumberSubtract(
+  num1: string,
+  num2: string,
+  p?: { decimal?: boolean; stayZero?: boolean }
+): string {
+  if (num1 === num2) return "0";
+  const { decimal, stayZero } = p || {};
+  const number1 = removeInvalidZero(num1);
+  const number2 = removeInvalidZero(num2);
+  const isFirstLarger = compareLargeIntegerNumber(number1, number2) > 0;
+  const maxNumber = isFirstLarger ? number1 : number2;
+  const minNumber = isFirstLarger ? number2 : number1;
+  const newNumber: string[] = [];
+  // step 存储借位信息
+  const step = [];
+  const diff = decimal ? 0 : maxNumber.length - minNumber.length;
+  const len = decimal ? minNumber.length : maxNumber.length;
+  for (let i = len - 1; i >= 0; i--) {
+    const minIndex = i - diff;
+    // 第一个数，减第二个数，减借位
+    let count = Number(maxNumber[i]) - (Number(minNumber[minIndex]) || 0) - (step[i] || 0);
+    if (count < 0) {
+      step[i - 1] = 1;
+      count += 10;
+    }
+    newNumber.unshift(String(count));
+  }
+  if (decimal) {
+    return newNumber.concat(maxNumber.slice(len, maxNumber.length)).join("");
+  }
+  let finalNumber = newNumber.join("");
+  if (!stayZero) {
+    finalNumber = finalNumber.replace(/^0+/, "");
+  }
+  return removeInvalidZero(isFirstLarger ? finalNumber : `-${finalNumber}`);
+}
+
+/**
+ * 大数减法，支持整数和小数（无精度问题）
+ * @param num1 被减数
+ * @param num2 减数
+ * @param decimal 是否为小数位相减
+ */
+export function largePositiveNumberSubtract(num1: string, num2: string): string {
+  if (num1 === num2) return "0";
+  const isFirstLarger = compareNumber(num1, num2, true) > 0;
+  const maxNumber = isFirstLarger ? num1 : num2;
+  const minNumber = isFirstLarger ? num2 : num1;
+  // 整数部分和小数部分分开处理
+  const [intNumber1, decimalNumber1 = "0"] = maxNumber.split(".");
+  const [intNumber2, decimalNumber2 = "0"] = minNumber.split(".");
+  let integerNumber = largeIntegerNumberSubtract(intNumber1, intNumber2);
+  // 如果不存在小数，则直接返回整数相加结果
+  if (decimalNumber1 === "0" && decimalNumber2 === "0") {
+    return isFirstLarger ? integerNumber : `-${integerNumber}`;
+  }
+  // 小数点相减
+  let decimalNumber = "";
+  let addOneNumber = decimalNumber1;
+  // 第一个数字的小数位数比第二个少，需补足 0
+  if (decimalNumber1.length < decimalNumber2.length) {
+    addOneNumber = `${decimalNumber1}${fillZero(decimalNumber2.length - decimalNumber1.length)}`;
+  }
+  // 第一个小数位更小，是否需要借位
+  if (compareLargeDecimalNumber(addOneNumber, decimalNumber2) >= 0) {
+    decimalNumber = largeIntegerNumberSubtract(addOneNumber, decimalNumber2, { decimal: true });
+  } else {
+    if (decimalNumber1.length < decimalNumber2.length || decimalNumber1 === "0") {
+      decimalNumber = largeIntegerNumberSubtract(`1${addOneNumber}`, decimalNumber2, { stayZero: true });
+      decimalNumber = fillZero(decimalNumber2.length - decimalNumber.length) + decimalNumber;
+    } else {
+      decimalNumber = largeIntegerNumberSubtract(decimalNumber1, decimalNumber2, { decimal: true });
+    }
+    integerNumber = largeIntegerNumberSubtract(integerNumber, "1");
+  }
+  const finalNumber = decimalNumber ? [integerNumber, decimalNumber].join(".") : integerNumber;
+  return isFirstLarger ? finalNumber : `-${finalNumber}`;
+}
+
+/**
+ * -0.6 - 0.8        =>  -(0.6 + 0.8)
+ * -0.6 - (-0.8)     =>  0.8 - 0.6
+ * 0.6 - (-0.8)      => 0.6 + 0.8
+ * 0.6 - 0.8         => 0.6 - 0.8
+ */
+export function largeNumberSubtract(num1: string, num2: string): string {
+  const isFirstNegative = num1[0] === "-";
+  const isSecondNegative = num2[0] === "-";
+  if (isFirstNegative && !isSecondNegative) {
+    const r = largePositiveNumberAdd(num1.slice(1), num2);
+    return `-${r}`;
+  }
+  if (isFirstNegative && isSecondNegative) {
+    return largePositiveNumberSubtract(num2.slice(1), num1.slice(1));
+  }
+  if (!isFirstNegative && isSecondNegative) {
+    return largePositiveNumberAdd(num1, num2.slice(1));
+  }
+  return largePositiveNumberSubtract(num1, num2);
+}
+
+/**
+ * -0.6 + 0.8        =>  0.8 - 0.6
+ * -0.6 + (-0.8)     =>  -(0.6 + 0.8)
+ * 0.6 + (-0.8)      => 0.6 - 0.8
+ * 0.6 + 0.8         => 0.6 + 0.8
+ */
+export function largeNumberAdd(num1: string, num2: string): string {
+  const isFirstNegative = num1[0] === "-";
+  const isSecondNegative = num2[0] === "-";
+  if (isFirstNegative && !isSecondNegative) {
+    return largePositiveNumberSubtract(num2, num1.slice(1));
+  }
+  if (isFirstNegative && isSecondNegative) {
+    const r = largePositiveNumberAdd(num2.slice(1), num1.slice(1));
+    return `-${r}`;
+  }
+  if (!isFirstNegative && isSecondNegative) {
+    return largePositiveNumberSubtract(num1, num2.slice(1));
+  }
+  return largePositiveNumberAdd(num1, num2);
+}
+
+/**
+ * 格式化小数，并且可以控制小数点后的位数和是否进行四舍五入。
+ *
+ * @param {number} num - 要格式化的数字。
+ * @param {number} places - 小数点后的位数。
+ * @param {boolean} rounding - 是否进行四舍五入。
+ * @returns {string} 格式化后的数字字符串。
+ */
+export function formatDecimal(num: number, places: number, enableRound: boolean = true) {
+  // 开启四舍五入 直接用 toFixed
+  if (enableRound) {
+    return num.toFixed(places);
+  }
+
+  const [integer, decimal] = num.toString().split(".");
+  // 保留 0 位小数
+  if (places === 0) {
+    return integer;
+  }
+  // 补足小数位数
+  if (decimal) {
+    let decimalNumber = decimal.slice(0, places);
+    if (decimal.length < places) {
+      decimalNumber += fillZero(places - decimal.length);
+    }
+    return [integer, decimalNumber].join(".");
+  }
+
+  return [integer, fillZero(places)].join(".");
+}
+
+export function decimalPlacesToFixedNum(num: number, decimalPlaces: InputNumberDecimalPlaces) {
+  if (isObject(decimalPlaces)) {
+    return formatDecimal(num, decimalPlaces.places, decimalPlaces.enableRound ?? true);
+  }
+  return formatDecimal(num, decimalPlaces, true);
+}
+
+/**
+ * 大数保留 N 位小数（没有精度问题）
+ * @param {String} number 大数（只能使用字符串表示）
+ * @param {Number} decimalPlaces 保留的小数位数
+ * @param {Boolean} largeNumber 是否为大数
+ */
+export function largeNumberToFixed(
+  number: string | number,
+  decimalPlaces: InputNumberDecimalPlaces = 0,
+  largeNumber: boolean = true
+): string {
+  if (Number.isNaN(Number(number))) return "";
+  if (!largeNumber) {
+    return decimalPlacesToFixedNum(Number(number), decimalPlaces);
+  }
+  const places = isObject(decimalPlaces) ? decimalPlaces.places : decimalPlaces;
+  const enableRound = isObject(decimalPlaces) ? decimalPlaces.enableRound ?? true : true;
+  if (!isString(number)) return String(number);
+
+  let [num1, num2] = number.split(".");
+  // 如果不存在小数点，则补足位数
+  if (!num2) {
+    return places > 0 && enableRound ? [number, fillZero(places)].join(".") : number;
+  }
+  // 存在小数点，保留 0 位小数，灵活配置四舍五入
+  if (places === 0) {
+    return enableRound && Number(num2[0]) >= 5 ? largePositiveNumberAdd(num1, "1") : num1;
+  }
+  // 存在小数点，保留 > 0 位小数，灵活配置四舍五入
+  let decimalNumber = num2.slice(0, places);
+  if (num2.length < places) {
+    decimalNumber += fillZero(places - num2.length);
+  } else if (enableRound) {
+    // 用于判断是否处于 1.08 这种小数为0开始的边界情况
+    const leadZeroNum = decimalNumber.match(/^0+/)?.[0].length;
+    // 用于判断是否处于 0.99/1.99 等需要往非0位进位的场景
+    const leadNineNum = decimalNumber.match(/^9+/);
+    // 决定是否需要四舍五入
+    const needAdded = Number(num2[places]) >= 5;
+
+    // 四舍五入后的结果
+    decimalNumber = needAdded ? largePositiveNumberAdd(decimalNumber, "1") : decimalNumber;
+
+    // 边界场景1（1.08 这种小数为0开始的边界情况）：计算后有误判的可能，如008 +1 误判为 8+1，需要手动补 0
+    if (leadZeroNum && needAdded && leadZeroNum + decimalNumber.length >= places) {
+      decimalNumber = `${fillZero(places - decimalNumber.length)}${decimalNumber}`;
+    }
+    // 边界场景2:（0.99 这种可能进位的边界情况）：计算后有误判的可能，如995 四舍五入后需进位
+    if (leadNineNum && decimalNumber.length > places) {
+      num1 = (Number(num1) + 1).toString();
+      decimalNumber = fillZero(places);
+    }
+  }
+  return [num1, decimalNumber].join(".");
+}

package/utils/input-number/number.ts

@@ -0,0 +1,257 @@
+import { isUndefined, isString, isNumber } from "lodash-es";
+/** 普通数相关方法 */
+import {
+  compareNumber,
+  formatENumber,
+  largeNumberToFixed,
+  isInputNumber,
+  largeNumberAdd,
+  largeNumberSubtract
+} from "./large-number";
+import log from "../log";
+import type { InputNumberDecimalPlaces } from "./large-number";
+
+export * from "./large-number";
+
+export type NumberType = number | string;
+
+// 小于最大值，才允许继续添加
+export function canAddNumber(num: NumberType, max: NumberType, largeNumber = false): boolean {
+  if (!num && num !== 0) return true;
+  if (largeNumber && isString(num)) {
+    return compareNumber(num, max, largeNumber) < 0;
+  }
+  return num < max;
+}
+
+// 大于最小值，才允许继续减少
+export function canReduceNumber(num: NumberType, min: NumberType, largeNumber = false): boolean {
+  if (!num && num !== 0) return true;
+  if (largeNumber && isString(num)) {
+    return compareNumber(num, min, largeNumber) > 0;
+  }
+  return num > min;
+}
+
+/**
+ * 将数字控制在 max 和 min 之间
+ */
+export function putInRangeNumber(
+  val: NumberType,
+  params: {
+    max?: NumberType;
+    min?: NumberType;
+    lastValue?: NumberType;
+    largeNumber?: boolean;
+  }
+) {
+  if (val === "") return undefined;
+  const { max, min, lastValue, largeNumber } = params;
+  if (!isInputNumber(val)) return lastValue;
+  if (largeNumber && (isString(max) || max === Infinity) && (isString(min) || min === -Infinity)) {
+    if (compareNumber(max, val, largeNumber) < 0) return max;
+    if (compareNumber(min, val, largeNumber) > 0) return min;
+    return val;
+  }
+  return Math.max(Number(min), Math.min(Number(max), Number(val)));
+}
+
+/**
+ * 仅支持正数，小数加法精度处理，小数部分和整数部分分开处理
+ */
+export function positiveAdd(num1: number, num2: number): number {
+  if (!num1 || !num2) return (num1 || 0) + (num2 || 0);
+  const r1 = num1.toString().split(".")[1]?.length || 0;
+  const r2 = num2.toString().split(".")[1]?.length || 0;
+  // 整数不存在精度问题，直接返回
+  if (!r1 && !r2) return num1 + num2;
+  let newNumber1 = num1;
+  let newNumber2 = num2;
+  const diff = Math.abs(r1 - r2);
+  const digit = 10 ** Math.max(r1, r2);
+  if (diff > 0) {
+    const cm = 10 ** diff;
+    if (r1 > r2) {
+      newNumber1 = Number(num1.toString().replace(".", ""));
+      newNumber2 = Number(num2.toString().replace(".", "")) * cm;
+    } else {
+      newNumber1 = Number(num1.toString().replace(".", "")) * cm;
+      newNumber2 = Number(num2.toString().replace(".", ""));
+    }
+  } else {
+    newNumber1 = Number(num1.toString().replace(".", ""));
+    newNumber2 = Number(num2.toString().replace(".", ""));
+  }
+  return (newNumber1 + newNumber2) / digit;
+}
+
+/**
+ * 正数，小数减法精度处理，小数部分和整数部分分开处理
+ */
+export function positiveSubtract(num1: number, num2: number): number {
+  if (!num1 || !num2) return (num1 || 0) - (num2 || 0);
+  const r1 = num1.toString().split(".")[1]?.length || 0;
+  const r2 = num2.toString().split(".")[1]?.length || 0;
+  const digit = 10 ** Math.max(r1, r2);
+  const n = r1 >= r2 ? r1 : r2;
+  return Number(((num1 * digit - num2 * digit) / digit).toFixed(n));
+}
+
+/**
+ * 支持正数、负数、小数等全部数字的加法
+ * -0.766 + 1       =>   1 - 0.766
+ * -1 + (-0.766)    =>   - (1 + 0.766)
+ * 1 + (-0.766)     =>   1 - 0.766
+ * 1 + 0.766        =>   1 + 0.766
+ */
+export function add(num1: number, num2: number): number {
+  if (num1 < 0 && num2 > 0) return positiveSubtract(num2, Math.abs(num1));
+  if (num1 < 0 && num2 < 0) return positiveAdd(Math.abs(num1), Math.abs(num2)) * -1;
+  if (num1 > 0 && num2 < 0) return positiveSubtract(num1, Math.abs(num2));
+  return positiveAdd(num1, num2);
+}
+
+/**
+ * 支持正数、负数、小数等全部数字的减法
+ * -0.766 - 1       =>   - (1 + 0.766)
+ * -1 - (-0.766)    =>   0.766 - 1
+ * 1 - (-0.766)     =>   1 + 0.766
+ * 1 - 0.766        =>   1 - 0.766
+ */
+export function subtract(num1: number, num2: number): number {
+  if (num1 < 0 && num2 > 0) return positiveAdd(Math.abs(num1), num2) * -1;
+  if (num1 < 0 && num2 < 0) return positiveSubtract(Math.abs(num2), Math.abs(num1));
+  if (num1 > 0 && num2 < 0) return positiveAdd(num1, Math.abs(num2));
+  return positiveSubtract(num1, num2);
+}
+
+export function getStepValue(p: {
+  op: "add" | "reduce";
+  step: NumberType;
+  max?: NumberType;
+  min?: NumberType;
+  lastValue?: NumberType;
+  largeNumber?: boolean;
+}) {
+  const { op, step, lastValue, max, min, largeNumber } = p;
+  if (Number(step) <= 0) {
+    log.error("InputNumber", "step must be larger than 0.");
+    return lastValue;
+  }
+  const tStep = isNumber(step) ? String(step) : step;
+  let newVal;
+  if (op === "add") {
+    if (largeNumber && isString(lastValue)) {
+      newVal = largeNumberAdd(String(lastValue), String(tStep));
+    } else {
+      newVal = add(Number(lastValue || 0), Number(step));
+    }
+  } else if (op === "reduce") {
+    if (largeNumber && isString(lastValue)) {
+      newVal = largeNumberSubtract(String(lastValue), String(tStep));
+    } else {
+      newVal = subtract(Number(lastValue || 0), Number(step));
+    }
+  }
+  if (isUndefined(lastValue)) {
+    newVal = putInRangeNumber(newVal, { max, min, lastValue, largeNumber });
+  }
+  return largeNumber ? newVal : Number(newVal);
+}
+
+export type InputNumberErrorType = "exceed-maximum" | "below-minimum" | undefined;
+
+/**
+ * 最大值和最小值校验
+ */
+export function getMaxOrMinValidateResult(p: {
+  largeNumber: boolean;
+  value: NumberType;
+  max: NumberType;
+  min: NumberType;
+}): InputNumberErrorType {
+  const { largeNumber, value, max, min } = p;
+  if (isUndefined(value) || isUndefined(largeNumber)) return undefined;
+  if (largeNumber && isNumber(value)) {
+    log.warn("InputNumber", "largeNumber value must be a string.");
+  }
+  let error: InputNumberErrorType;
+  if (compareNumber(value, max, largeNumber) > 0) {
+    error = "exceed-maximum";
+  } else if (compareNumber(value, min, largeNumber) < 0) {
+    error = "below-minimum";
+  } else {
+    error = undefined;
+  }
+  return error;
+}
+
+export const specialCode = ["-", ".", "e", "E", "+"];
+
+/**
+ * 是否允许输入当前字符，输入字符校验
+ * 1.23E+08 就表示 1.23 乘 10 的 8 次方
+ * 2e3 表示 2 乘 10 的 3 次方
+ */
+export function canInputNumber(number: string | undefined | null, largeNumber?: boolean) {
+  if (["", null, undefined].includes(number)) return true;
+  // 数字最前方不允许出现连续的两个 0
+  if (number.slice(0, 2) === "00") return false;
+  // 不能出现空格
+  if (number.match(/\s/g)) return false;
+  // 只能出现一个点（.）
+  if (number.match(/\./g)?.length > 1) return false;
+  // 只能出现一个e（e）
+  if (number.match(/e/g)?.length > 1) return false;
+  // 只能出现一个负号（-）或 一个正号（+），并且在第一个位置；但允许 3e+10 这种形式
+  const tmpNumber = number.slice(1);
+  const tmpMatched = tmpNumber.match(/(\+|-)/g);
+  if (tmpMatched && (!/e(\+|-)/i.test(tmpNumber) || tmpMatched.length > 1)) return false;
+  // 允许输入数字字符
+  const isNumber = (largeNumber && isInputNumber(number)) || !Number.isNaN(Number(number));
+  if (!isNumber && !specialCode.includes(number.slice(-1))) return false;
+  if (/e/i.test(number) && (!/\de/i.test(number) || /e\./.test(number))) return false;
+  return true;
+}
+
+/**
+ * 是否允许设置组件新值，触发 onChange 事件
+ */
+export function canSetValue(number: string, lastNumber: number) {
+  return parseFloat(number) !== lastNumber && !Number.isNaN(Number(number));
+}
+
+/**
+ * 1. 格式化未输入完成的数字，如：如：2e/2+/2.等
+ * 2. 处理小数点 decimalPlaces
+ * 3. 格式化大数字 formatENumber
+ */
+export function formatUnCompleteNumber(
+  number: string,
+  extra: {
+    decimalPlaces?: InputNumberDecimalPlaces;
+    largeNumber?: boolean;
+    isToFixed?: boolean;
+  } = {}
+): number | string {
+  if (["", null, undefined].includes(number) || !/\d+/.test(number)) return undefined;
+  const { decimalPlaces, largeNumber, isToFixed } = extra;
+  let newNumber = number.replace(/[.|+|\-|e]$/, "");
+  if (largeNumber) {
+    newNumber = formatENumber(newNumber);
+  }
+  if (decimalPlaces !== undefined) {
+    newNumber = largeNumberToFixed(newNumber, decimalPlaces, largeNumber);
+  }
+  if (largeNumber) return newNumber;
+  return isToFixed ? newNumber : parseFloat(newNumber);
+}
+
+/**
+ * 对千分位进行处理 111,111,222 -> 111111222
+ */
+export function formatThousandths(number: string) {
+  const thousandthsRegExp = /^[-+]?\d{1,3}(,\d{3})*(\.(\d*))?$/;
+  if (thousandthsRegExp.test(number)) return number.replace(/,/g, "");
+  return number;
+}

package/utils/isFragment.ts

@@ -9,14 +9,14 @@ const REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
  * Compatible with React 18 or 19 to check if node is a Fragment.
  */
 export default function isFragment(object: React.ReactElement | null | undefined): boolean {
+  if (!object || typeof object !== "object") return false;
+
+  const obj = object as unknown as { $$typeof?: symbol; type?: symbol | React.ElementType };
+
   return (
-    // Base object type
-    object &&
-    typeof object === "object" &&
     // React Element type
-    ((object as { $$typeof: symbol }).$$typeof === REACT_ELEMENT_TYPE_18 ||
-      (object as { $$typeof: symbol }).$$typeof === REACT_ELEMENT_TYPE_19) &&
+    (obj.$$typeof === REACT_ELEMENT_TYPE_18 || obj.$$typeof === REACT_ELEMENT_TYPE_19) &&
     // React Fragment type
-    (object as { type: symbol }).type === REACT_FRAGMENT_TYPE
+    obj.type === REACT_FRAGMENT_TYPE
   );
 }