n20-common-lib 3.3.14 → 3.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n20-common-lib",
-  "version": "3.3.14",
+  "version": "3.3.15",
   "private": false,
   "scripts": {
     "serve": "vue-cli-service serve",

package/src/components/Descriptions/index.vue

@@ -1,8 +1,8 @@
 <template>
-  <el-descriptions class="n20-descriptions" :column="column" size="default" border>
+  <el-descriptions class="n20-descriptions" :column="currentColumn" size="default" border>
     <slot></slot>
-    <template v-if="this.$slots.default.length === 1">
-      <el-descriptions-item v-for="(item, index) in column - 1" :key="index" />
+    <template v-if="this.$slots.default && this.$slots.default.length === 1">
+      <el-descriptions-item v-for="(item, index) in currentColumn - 1" :key="index" />
     </template>
   </el-descriptions>
 </template>
@@ -20,28 +20,48 @@ export default {
       default: true
     }
   },
-  created() {
-    if (this.autoResize) {
-      this.resize()
-      window.addEventListener('resize', this.resize)
+  data() {
+    return {
+      currentColumn: this.column
+    }
+  },
+  watch: {
+    column(val) {
+      this.currentColumn = val
+    },
+    autoResize(val) {
+      if (val) {
+        this.createResize()
+      } else {
+        this.currentColumn = this.column
+        this.destroyResize()
+      }
     }
   },
+  created() {
+    if (!this.autoResize) return
+    this.createResize()
+  },
   beforeDestroy() {
-    window.removeEventListener('resize', this.resize)
+    this.destroyResize()
   },
   methods: {
     resize() {
       let wW = document.documentElement.clientWidth
       if (wW <= 1024) {
-        this.column = 1
+        this.currentColumn = 1
       } else if (wW > 1024 && wW <= 1600) {
-        this.column = 2
+        this.currentColumn = 2
       } else if (wW > 1600 && wW <= 1920) {
-        this.column = 3
+        this.currentColumn = 3
       } else if (wW > 1920) {
-        this.column = 4
+        this.currentColumn = 4
       }
     },
+    createResize() {
+      this.resize()
+      window.addEventListener('resize', this.resize)
+    },
     destroyResize() {
       window.removeEventListener('resize', this.resize)
     }

package/src/components/InputNumber/README.md

@@ -31,10 +31,11 @@
 | disabled     | Boolean       | undefined         | 是否禁用                              |
 | isClearable  | Boolean       | false             | 是否可清空                             |
 | placeholder  | String        | '请输入'             | 占位提示文本                            |
-| dNum         | Number        | undefined         | 小数位数，优先级低于format                  |
+| dNum         | Number        | undefined         | 小数位数，优先级低于format；超过15位时以字符串保持精度 |
 | format       | String        | undefined         | 格式化字符串，如'0.00'表示保留2位小数            |
 | suffix       | String        | '%'               | 后缀文本，仅在type='rate'时有效             |
 | rangeAuto    | Boolean       | false             | 是否自动处理范围值                         |
+| isString     | Boolean       | false             | 是否始终以字符串回传 input/change 值；小数位超过15位时自动按 true 处理 |
 
 ## 类型说明
 
@@ -60,6 +61,8 @@
 
 ## 事件
 
+当 `dNum` 或 `format` 设置为超过 15 位小数时，组件会强制按 `isString=true` 处理，即使未显式配置 `isString`，`input` 和 `change` 也会回传字符串，避免 JavaScript `Number` 丢失精度；失焦时会按最大位数四舍五入并移除尾部 `0`，例如 `0.200000` 会回传 `"0.2"`。设置 `isString` 为 `true` 后，无论小数位数多少，`input` 和 `change` 都回传字符串；清空时回传空字符串。
+
 | 事件名    | 说明          | 回调参数 |
 | ------ | ----------- | ---- |
 | input  | 值改变时触发      | 当前值  |
@@ -109,4 +112,3 @@
 <!-- 启用步进严格模式 -->
 <InputNumber v-model="value" type="number" :step="0.5" :stepStrictly="true" />
 ```
-

package/src/components/InputNumber/index.vue

@@ -33,7 +33,9 @@
 <script>
 import emitter from '../../utils/element-ui-emitter'
 import { $lc } from '../../utils/i18n/index'
-import N from '../../utils/numberPor'
+import N, { addDecimal, compareDecimal, decimalToFixed, normalizeDecimal } from '../../utils/numberPor'
+
+const MAX_SAFE_DECIMAL_PLACES = 15
 
 export default {
   name: 'InputNumber',
@@ -103,6 +105,10 @@ export default {
     rangeAuto: {
       type: Boolean,
       default: false
+    },
+    isString: {
+      type: Boolean,
+      default: false
     }
   },
   data() {
@@ -155,6 +161,20 @@ export default {
   watch: {
     value: {
       handler(val) {
+        if (this.isHighPrecision()) {
+          if (val === undefined || val === null || val === '') {
+            this.valueStr = ''
+          } else {
+            const normalized = normalizeDecimal(val)
+            if (!normalized) {
+              this.valueStr = ''
+              return
+            }
+            const formatted = this.normalizeHighPrecisionValue(normalized)
+            this.valueStr = this.type === 'number' ? formatted : N.addThousands(formatted)
+          }
+          return
+        }
         // number类型不启用千分位格式化，但应用小数位限制
         if (this.type === 'number') {
           if (val === undefined || val === null) {
@@ -189,6 +209,23 @@ export default {
     }
   },
   methods: {
+    isHighPrecision() {
+      return this.fNum > MAX_SAFE_DECIMAL_PLACES
+    },
+    // 高精度小数会强制使用字符串回传，即使 isString 未开启。
+    shouldEmitString() {
+      return this.isString || this.isHighPrecision()
+    },
+    normalizeHighPrecisionValue(value) {
+      const normalized = normalizeDecimal(value)
+      if (!normalized) return ''
+
+      const decimalPart = normalized.split('.')[1] || ''
+      const roundedValue = this.rangeAuto && decimalPart.length >= this.fNum
+        ? normalized
+        : decimalToFixed(normalized, this.fNum)
+      return normalizeDecimal(roundedValue)
+    },
     focusFn() {
       this.isFocus = true
       if (!this.disabled && this.valueStr) {
@@ -210,6 +247,24 @@ export default {
     },
     stepFn(ev) {
       if ((ev.code === 'ArrowUp' || ev.code === 'ArrowDown') && !this.disabled) {
+        if (this.isHighPrecision()) {
+          const currentValue = normalizeDecimal(this.valueStr)
+          if (!currentValue) return
+
+          ev.preventDefault()
+          const stepValue = N.toString(this.step)
+          let nextValue = addDecimal(currentValue, ev.code === 'ArrowUp' ? stepValue : '-' + stepValue)
+          if (compareDecimal(nextValue, this.min) < 0) {
+            nextValue = normalizeDecimal(this.min)
+          } else if (compareDecimal(nextValue, this.max) > 0) {
+            nextValue = normalizeDecimal(this.max)
+          }
+
+          const formatted = this.normalizeHighPrecisionValue(nextValue)
+          this.valueStr = this.type === 'number' ? formatted : N.addThousands(formatted)
+          return
+        }
+
         let val = N(this.valueStr)
         if (!isNaN(val)) {
           ev.preventDefault()
@@ -243,14 +298,51 @@ export default {
         this.changeIng = false
       })
 
+      if (this.isHighPrecision()) {
+        const normalized = normalizeDecimal(valStr)
+        if (!normalized) {
+          this.valueStr = ''
+          const oldValue = this.value
+          if (oldValue || oldValue === 0 || oldValue === '0') {
+            const emptyValue = this.shouldEmitString() ? '' : undefined
+            this.$emit('input', emptyValue)
+            this.$emit('change', emptyValue)
+            this.dispatch('ElFormItem', 'el.form.change', [emptyValue])
+          }
+          return
+        }
+
+        let nextValue = this.normalizeHighPrecisionValue(normalized)
+
+        if (compareDecimal(nextValue, this.min) < 0) {
+          nextValue = normalizeDecimal(this.min)
+        } else if (compareDecimal(nextValue, this.max) > 0) {
+          nextValue = normalizeDecimal(this.max)
+        }
+
+        const formatted = this.type === 'number' ? nextValue : N.addThousands(nextValue)
+        this.valueStr = formatted
+        this.$nextTick(() => {
+          const oldValue = normalizeDecimal(this.value)
+          const normalizedNextValue = normalizeDecimal(nextValue)
+          if (oldValue !== normalizedNextValue) {
+            this.$emit('input', nextValue)
+            this.$emit('change', nextValue)
+            this.dispatch('ElFormItem', 'el.form.change', [nextValue])
+          }
+        })
+        return
+      }
+
       let val = N(valStr)
       if (isNaN(val)) {
         this.valueStr = ''
         let oVal = this.value
         if (oVal || oVal === 0) {
-          this.$emit('input', undefined)
-          this.$emit('change', undefined)
-          this.dispatch('ElFormItem', 'el.form.change', [undefined])
+          const emptyValue = this.shouldEmitString() ? '' : undefined
+          this.$emit('input', emptyValue)
+          this.$emit('change', emptyValue)
+          this.dispatch('ElFormItem', 'el.form.change', [emptyValue])
         }
         return
       }
@@ -294,10 +386,12 @@ export default {
       this.$nextTick(() => {
         let nVar = Number(nStr)
         let oVal = this.value
-        if (oVal !== nVar) {
-          this.$emit('input', nVar)
-          this.$emit('change', nVar)
-          this.dispatch('ElFormItem', 'el.form.change', [nVar])
+        const emittedValue = this.shouldEmitString() ? nStr : nVar
+        const valueChanged = this.shouldEmitString() ? String(oVal) !== nStr : oVal !== nVar
+        if (valueChanged) {
+          this.$emit('input', emittedValue)
+          this.$emit('change', emittedValue)
+          this.dispatch('ElFormItem', 'el.form.change', [emittedValue])
         }
       })
     }

package/src/utils/numberPor.js

@@ -197,6 +197,198 @@ export const subFixed = function (n, decimal = 6) {
     return XEUtils.toFixed(n, decimal)
   }
 }
+
+const decimalPattern = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/
+
+function padRight(value, length) {
+  return value + '0'.repeat(Math.max(0, length - value.length))
+}
+
+function padLeft(value, length) {
+  return '0'.repeat(Math.max(0, length - value.length)) + value
+}
+
+/**
+ * 规范化十进制数字字符串，不经过 Number，避免高精度小数丢失精度。
+ * @param {number|string} value
+ * @returns {string}
+ */
+export const normalizeDecimal = function (value) {
+  if (value === undefined || value === null || value === '') return ''
+
+  const stringValue = toString(value).replace(/,/g, '').trim()
+  if (!decimalPattern.test(stringValue)) return ''
+
+  const sign = stringValue.charAt(0) === '-' ? '-' : ''
+  const unsignedValue = stringValue.replace(/^[+-]/, '')
+  let [integerPart = '0', decimalPart = ''] = unsignedValue.split('.')
+  integerPart = integerPart.replace(/^0+(?=\d)/, '') || '0'
+  decimalPart = decimalPart.replace(/0+$/, '')
+
+  return sign + integerPart + (decimalPart ? '.' + decimalPart : '')
+}
+
+function compareUnsignedDecimal(a, b) {
+  let [aInteger = '0', aDecimal = ''] = a.split('.')
+  let [bInteger = '0', bDecimal = ''] = b.split('.')
+  aInteger = aInteger.replace(/^0+(?=\d)/, '') || '0'
+  bInteger = bInteger.replace(/^0+(?=\d)/, '') || '0'
+
+  if (aInteger.length !== bInteger.length) {
+    return aInteger.length > bInteger.length ? 1 : -1
+  }
+  if (aInteger !== bInteger) return aInteger > bInteger ? 1 : -1
+
+  const decimalLength = Math.max(aDecimal.length, bDecimal.length)
+  aDecimal = padRight(aDecimal, decimalLength)
+  bDecimal = padRight(bDecimal, decimalLength)
+  if (aDecimal === bDecimal) return 0
+  return aDecimal > bDecimal ? 1 : -1
+}
+
+/**
+ * 比较两个十进制数字字符串。
+ * @param {number|string} left
+ * @param {number|string} right
+ * @returns {number} -1、0、1
+ */
+export const compareDecimal = function (left, right) {
+  const a = normalizeDecimal(left)
+  const b = normalizeDecimal(right)
+  if (!a || !b) return NaN
+
+  const aNegative = a.charAt(0) === '-'
+  const bNegative = b.charAt(0) === '-'
+  const aUnsigned = a.replace(/^-/, '')
+  const bUnsigned = b.replace(/^-/, '')
+
+  if (aNegative !== bNegative) return aNegative ? -1 : 1
+  const result = compareUnsignedDecimal(aUnsigned, bUnsigned)
+  return aNegative ? -result : result
+}
+
+function incrementUnsignedDecimal(value) {
+  const digits = value.split('')
+  for (let i = digits.length - 1; i >= 0; i -= 1) {
+    if (digits[i] === '9') {
+      digits[i] = '0'
+    } else {
+      digits[i] = String(Number(digits[i]) + 1)
+      return digits.join('')
+    }
+  }
+  return '1' + digits.join('')
+}
+
+/**
+ * 使用字符串运算按指定小数位四舍五入，不经过 Number。
+ * @param {number|string} value
+ * @param {number} decimal
+ * @returns {string}
+ */
+export const decimalToFixed = function (value, decimal = 0) {
+  const normalized = normalizeDecimal(value)
+  if (!normalized) return ''
+
+  const precision = Math.max(0, Number(decimal) || 0)
+  const negative = normalized.charAt(0) === '-'
+  const unsignedValue = normalized.replace(/^-/, '')
+  let [integerPart = '0', decimalPart = ''] = unsignedValue.split('.')
+  const shouldRound = decimalPart.length > precision && decimalPart.charAt(precision) >= '5'
+  decimalPart = padRight(decimalPart.slice(0, precision), precision)
+
+  if (shouldRound) {
+    const incremented = incrementUnsignedDecimal(integerPart + decimalPart)
+    integerPart = incremented.slice(0, Math.max(1, incremented.length - precision))
+    decimalPart = precision ? padLeft(incremented.slice(-precision), precision) : ''
+  }
+
+  return (negative ? '-' : '') + integerPart + (precision ? '.' + decimalPart : '')
+}
+
+function addUnsignedDecimal(left, right) {
+  let [leftInteger = '0', leftDecimal = ''] = left.split('.')
+  let [rightInteger = '0', rightDecimal = ''] = right.split('.')
+  const decimalLength = Math.max(leftDecimal.length, rightDecimal.length)
+  leftDecimal = padRight(leftDecimal, decimalLength)
+  rightDecimal = padRight(rightDecimal, decimalLength)
+
+  let carry = 0
+  let result = ''
+  const leftDigits = (leftInteger + leftDecimal).split('')
+  const rightDigits = (rightInteger + rightDecimal).split('')
+  const length = Math.max(leftDigits.length, rightDigits.length)
+  for (let i = 0; i < length; i += 1) {
+    const leftDigit = Number(leftDigits[leftDigits.length - 1 - i] || 0)
+    const rightDigit = Number(rightDigits[rightDigits.length - 1 - i] || 0)
+    const sum = leftDigit + rightDigit + carry
+    result = String(sum % 10) + result
+    carry = Math.floor(sum / 10)
+  }
+  if (carry) result = String(carry) + result
+
+  const integerLength = result.length - decimalLength
+  const integerPart = result.slice(0, Math.max(1, integerLength))
+  const decimalPart = decimalLength ? result.slice(-decimalLength) : ''
+  return integerPart + (decimalPart ? '.' + decimalPart : '')
+}
+
+function subtractUnsignedDecimal(left, right) {
+  let [leftInteger = '0', leftDecimal = ''] = left.split('.')
+  let [rightInteger = '0', rightDecimal = ''] = right.split('.')
+  const decimalLength = Math.max(leftDecimal.length, rightDecimal.length)
+  leftDecimal = padRight(leftDecimal, decimalLength)
+  rightDecimal = padRight(rightDecimal, decimalLength)
+
+  let borrow = 0
+  let result = ''
+  const leftDigits = (leftInteger + leftDecimal).split('')
+  const rightDigits = (rightInteger + rightDecimal).split('')
+  const length = Math.max(leftDigits.length, rightDigits.length)
+  for (let i = 0; i < length; i += 1) {
+    let leftDigit = Number(leftDigits[leftDigits.length - 1 - i] || 0) - borrow
+    const rightDigit = Number(rightDigits[rightDigits.length - 1 - i] || 0)
+    if (leftDigit < rightDigit) {
+      leftDigit += 10
+      borrow = 1
+    } else {
+      borrow = 0
+    }
+    result = String(leftDigit - rightDigit) + result
+  }
+
+  const integerLength = result.length - decimalLength
+  const integerPart = result.slice(0, Math.max(1, integerLength)).replace(/^0+(?=\d)/, '') || '0'
+  const decimalPart = decimalLength ? result.slice(-decimalLength) : ''
+  return integerPart + (decimalPart ? '.' + decimalPart : '')
+}
+
+/**
+ * 高精度十进制加法，不经过 Number。
+ * @param {number|string} left
+ * @param {number|string} right
+ * @returns {string}
+ */
+export const addDecimal = function (left, right) {
+  const a = normalizeDecimal(left)
+  const b = normalizeDecimal(right)
+  if (!a || !b) return ''
+
+  const aNegative = a.charAt(0) === '-'
+  const bNegative = b.charAt(0) === '-'
+  const aUnsigned = a.replace(/^-/, '')
+  const bUnsigned = b.replace(/^-/, '')
+
+  if (aNegative === bNegative) {
+    const result = addUnsignedDecimal(aUnsigned, bUnsigned)
+    return (aNegative ? '-' : '') + normalizeDecimal(result)
+  }
+
+  const comparison = compareUnsignedDecimal(aUnsigned, bUnsigned)
+  if (comparison === 0) return '0'
+  if (comparison > 0) return (aNegative ? '-' : '') + normalizeDecimal(subtractUnsignedDecimal(aUnsigned, bUnsigned))
+  return (bNegative ? '-' : '') + normalizeDecimal(subtractUnsignedDecimal(bUnsigned, aUnsigned))
+}
 /**
  * 将数字或字符串格式的数字转换为千位分隔符格式的字符串
  * @param {number|string} number - 待转换的数字或字符串格式的数字