@antsoo-lib/components 0.1.11 → 0.1.13

package/src/input-number/src/hooks/useCursor.ts

@@ -1,79 +0,0 @@
-import type { Ref } from 'vue'
-import { ref } from 'vue'
-
-import { warning } from '../../../vc-util/warning'
-
-/**
- * Keep input cursor in the correct position if possible.
- * Is this necessary since we have `formatter` which may mass the content?
- */
-export default function useCursor(
-  inputRef: Ref<HTMLInputElement>,
-  focused: Ref<boolean>,
-): [() => void, () => void] {
-  const selectionRef = ref<{
-    start?: number
-    end?: number
-    value?: string
-    beforeTxt?: string
-    afterTxt?: string
-  }>(null)
-
-  function recordCursor() {
-    // Record position
-    try {
-      const { selectionStart: start, selectionEnd: end, value } = inputRef.value
-      const beforeTxt = value.substring(0, start)
-      const afterTxt = value.substring(end)
-
-      selectionRef.value = {
-        start,
-        end,
-        value,
-        beforeTxt,
-        afterTxt,
-      }
-    } catch (e) {
-      // Fix error in Chrome:
-      // Failed to read the 'selectionStart' property from 'HTMLInputElement'
-      // http://stackoverflow.com/q/21177489/3040605
-    }
-  }
-
-  /**
-   * Restore logic:
-   *  1. back string same
-   *  2. start string same
-   */
-  function restoreCursor() {
-    if (inputRef.value && selectionRef.value && focused.value) {
-      try {
-        const { value } = inputRef.value
-        const { beforeTxt, afterTxt, start } = selectionRef.value
-
-        let startPos = value.length
-
-        if (value.endsWith(afterTxt)) {
-          startPos = value.length - selectionRef.value.afterTxt.length
-        } else if (value.startsWith(beforeTxt)) {
-          startPos = beforeTxt.length
-        } else {
-          const beforeLastChar = beforeTxt[start - 1]
-          const newIndex = value.indexOf(beforeLastChar, start - 1)
-          if (newIndex !== -1) {
-            startPos = newIndex + 1
-          }
-        }
-
-        inputRef.value.setSelectionRange(startPos, startPos)
-      } catch (e) {
-        warning(
-          false,
-          `Something warning of cursor restore. Please fire issue about this: ${e.message}`,
-        )
-      }
-    }
-  }
-
-  return [recordCursor, restoreCursor]
-}

package/src/input-number/src/hooks/useFrame.ts

@@ -1,26 +0,0 @@
-import { onBeforeUnmount, shallowRef } from 'vue'
-
-import raf from '../../../_util/raf'
-
-/**
- * Always trigger latest once when call multiple time
- */
-export default () => {
-  const idRef = shallowRef(0)
-
-  const cleanUp = () => {
-    raf.cancel(idRef.value)
-  }
-
-  onBeforeUnmount(() => {
-    cleanUp()
-  })
-
-  return (callback: () => void) => {
-    cleanUp()
-
-    idRef.value = raf(() => {
-      callback()
-    })
-  }
-}

package/src/input-number/src/utils/MiniDecimal.ts

@@ -1,307 +0,0 @@
-import { getNumberPrecision, isE, num2str, trimNumber, validateNumber } from './numberUtil'
-import { supportBigInt } from './supportUtil'
-
-export type ValueType = string | number
-
-function isEmpty(value: ValueType) {
-  return (!value && value !== 0 && !Number.isNaN(value)) || !String(value).trim()
-}
-
-export interface DecimalClass {
-  add: (value: ValueType) => DecimalClass
-
-  isEmpty: () => boolean
-
-  isNaN: () => boolean
-
-  isInvalidate: () => boolean
-
-  toNumber: () => number
-
-  /**
-   * Parse value as string. Will return empty string if `isInvalidate`.
-   * You can set `safe=false` to get origin string content.
-   */
-  toString: (safe?: boolean) => string
-
-  equals: (target: DecimalClass) => boolean
-
-  lessEquals: (target: DecimalClass) => boolean
-
-  negate: () => DecimalClass
-}
-
-/**
- * We can remove this when IE not support anymore
- */
-export class NumberDecimal implements DecimalClass {
-  origin = ''
-  number: number
-  empty: boolean
-
-  constructor(value: ValueType) {
-    if (isEmpty(value)) {
-      this.empty = true
-      return
-    }
-
-    this.origin = String(value)
-    this.number = Number(value)
-  }
-
-  negate() {
-    return new NumberDecimal(-this.toNumber())
-  }
-
-  add(value: ValueType) {
-    if (this.isInvalidate()) {
-      return new NumberDecimal(value)
-    }
-
-    const target = Number(value)
-
-    if (Number.isNaN(target)) {
-      return this
-    }
-
-    const number = this.number + target
-
-    // [Legacy] Back to safe integer
-    if (number > Number.MAX_SAFE_INTEGER) {
-      return new NumberDecimal(Number.MAX_SAFE_INTEGER)
-    }
-
-    if (number < Number.MIN_SAFE_INTEGER) {
-      return new NumberDecimal(Number.MIN_SAFE_INTEGER)
-    }
-
-    const maxPrecision = Math.max(getNumberPrecision(this.number), getNumberPrecision(target))
-    return new NumberDecimal(number.toFixed(maxPrecision))
-  }
-
-  isEmpty() {
-    return this.empty
-  }
-
-  isNaN() {
-    return Number.isNaN(this.number)
-  }
-
-  isInvalidate() {
-    return this.isEmpty() || this.isNaN()
-  }
-
-  equals(target: DecimalClass) {
-    return this.toNumber() === target?.toNumber()
-  }
-
-  lessEquals(target: DecimalClass) {
-    return this.add(target.negate().toString()).toNumber() <= 0
-  }
-
-  toNumber() {
-    return this.number
-  }
-
-  toString(safe = true) {
-    if (!safe) {
-      return this.origin
-    }
-
-    if (this.isInvalidate()) {
-      return ''
-    }
-
-    return num2str(this.number)
-  }
-}
-
-export class BigIntDecimal implements DecimalClass {
-  origin = ''
-  negative: boolean
-  integer: bigint
-  decimal: bigint
-  /** BigInt will convert `0009` to `9`. We need record the len of decimal */
-  decimalLen: number
-  empty: boolean
-  nan: boolean
-
-  constructor(value: string | number) {
-    if (isEmpty(value)) {
-      this.empty = true
-      return
-    }
-
-    this.origin = String(value)
-
-    // Act like Number convert
-    if (value === '-' || Number.isNaN(value)) {
-      this.nan = true
-      return
-    }
-
-    let mergedValue = value
-
-    // We need convert back to Number since it require `toFixed` to handle this
-    if (isE(mergedValue)) {
-      mergedValue = Number(mergedValue)
-    }
-
-    mergedValue = typeof mergedValue === 'string' ? mergedValue : num2str(mergedValue)
-
-    if (validateNumber(mergedValue)) {
-      const trimRet = trimNumber(mergedValue)
-      this.negative = trimRet.negative
-      const numbers = trimRet.trimStr.split('.')
-      this.integer = BigInt(numbers[0])
-      const decimalStr = numbers[1] || '0'
-      this.decimal = BigInt(decimalStr)
-      this.decimalLen = decimalStr.length
-    } else {
-      this.nan = true
-    }
-  }
-
-  private getMark() {
-    return this.negative ? '-' : ''
-  }
-
-  private getIntegerStr() {
-    return this.integer.toString()
-  }
-
-  private getDecimalStr() {
-    return this.decimal.toString().padStart(this.decimalLen, '0')
-  }
-
-  /**
-   * Align BigIntDecimal with same decimal length. e.g. 12.3 + 5 = 1230000
-   * This is used for add function only.
-   */
-  private alignDecimal(decimalLength: number): bigint {
-    const str = `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(
-      decimalLength,
-      '0',
-    )}`
-    return BigInt(str)
-  }
-
-  negate() {
-    const clone = new BigIntDecimal(this.toString())
-    clone.negative = !clone.negative
-    return clone
-  }
-
-  add(value: ValueType): BigIntDecimal {
-    if (this.isInvalidate()) {
-      return new BigIntDecimal(value)
-    }
-
-    const offset = new BigIntDecimal(value)
-    if (offset.isInvalidate()) {
-      return this
-    }
-
-    const maxDecimalLength = Math.max(this.getDecimalStr().length, offset.getDecimalStr().length)
-    const myAlignedDecimal = this.alignDecimal(maxDecimalLength)
-    const offsetAlignedDecimal = offset.alignDecimal(maxDecimalLength)
-
-    const valueStr = (myAlignedDecimal + offsetAlignedDecimal).toString()
-
-    // We need fill string length back to `maxDecimalLength` to avoid parser failed
-    const { negativeStr, trimStr } = trimNumber(valueStr)
-    const hydrateValueStr = `${negativeStr}${trimStr.padStart(maxDecimalLength + 1, '0')}`
-
-    return new BigIntDecimal(
-      `${hydrateValueStr.slice(0, -maxDecimalLength)}.${hydrateValueStr.slice(-maxDecimalLength)}`,
-    )
-  }
-
-  isEmpty() {
-    return this.empty
-  }
-
-  isNaN() {
-    return this.nan
-  }
-
-  isInvalidate() {
-    return this.isEmpty() || this.isNaN()
-  }
-
-  equals(target: DecimalClass) {
-    return this.toString() === target?.toString()
-  }
-
-  lessEquals(target: DecimalClass) {
-    return this.add(target.negate().toString()).toNumber() <= 0
-  }
-
-  toNumber() {
-    if (this.isNaN()) {
-      return Number.NaN
-    }
-    return Number(this.toString())
-  }
-
-  toString(safe = true) {
-    if (!safe) {
-      return this.origin
-    }
-
-    if (this.isInvalidate()) {
-      return ''
-    }
-
-    return trimNumber(`${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`).fullStr
-  }
-}
-
-export default function getMiniDecimal(value: ValueType): DecimalClass {
-  // We use BigInt here.
-  // Will fallback to Number if not support.
-  if (supportBigInt()) {
-    return new BigIntDecimal(value)
-  }
-  return new NumberDecimal(value)
-}
-
-/**
- * Align the logic of toFixed to around like 1.5 => 2.
- * If set `cutOnly`, will just remove the over decimal part.
- */
-export function toFixed(numStr: string, separatorStr: string, precision?: number, cutOnly = false) {
-  if (numStr === '') {
-    return ''
-  }
-  const { negativeStr, integerStr, decimalStr } = trimNumber(numStr)
-  const precisionDecimalStr = `${separatorStr}${decimalStr}`
-
-  const numberWithoutDecimal = `${negativeStr}${integerStr}`
-
-  if (precision >= 0) {
-    // We will get last + 1 number to check if need advanced number
-    const advancedNum = Number(decimalStr[precision])
-
-    if (advancedNum >= 5 && !cutOnly) {
-      const advancedDecimal = getMiniDecimal(numStr).add(
-        `${negativeStr}0.${'0'.repeat(precision)}${10 - advancedNum}`,
-      )
-      return toFixed(advancedDecimal.toString(), separatorStr, precision, cutOnly)
-    }
-
-    if (precision === 0) {
-      return numberWithoutDecimal
-    }
-
-    return `${numberWithoutDecimal}${separatorStr}${decimalStr
-      .padEnd(precision, '0')
-      .slice(0, precision)}`
-  }
-
-  if (precisionDecimalStr === '.0') {
-    return numberWithoutDecimal
-  }
-
-  return `${numberWithoutDecimal}${precisionDecimalStr}`
-}

package/src/input-number/src/utils/numberUtil.ts

@@ -1,115 +0,0 @@
-import { supportBigInt } from './supportUtil'
-
-/**
- * Format string number to readable number
- */
-export function trimNumber(numStr: string) {
-  let str = numStr.trim()
-
-  let negative = str.startsWith('-')
-
-  if (negative) {
-    str = str.slice(1)
-  }
-
-  str = str
-    // Remove decimal 0. `1.000` => `1.`, `1.100` => `1.1`
-    .replace(/(\.\d*[^0])0*$/, '$1')
-    // Remove useless decimal. `1.` => `1`
-    .replace(/\.0*$/, '')
-    // Remove integer 0. `0001` => `1`, 000.1' => `.1`
-    .replace(/^0+/, '')
-
-  if (str.startsWith('.')) {
-    str = `0${str}`
-  }
-
-  const trimStr = str || '0'
-  const splitNumber = trimStr.split('.')
-
-  const integerStr = splitNumber[0] || '0'
-  const decimalStr = splitNumber[1] || '0'
-
-  if (integerStr === '0' && decimalStr === '0') {
-    negative = false
-  }
-
-  const negativeStr = negative ? '-' : ''
-
-  return {
-    negative,
-    negativeStr,
-    trimStr,
-    integerStr,
-    decimalStr,
-    fullStr: `${negativeStr}${trimStr}`,
-  }
-}
-
-export function isE(number: string | number) {
-  const str = String(number)
-
-  return !Number.isNaN(Number(str)) && str.includes('e')
-}
-
-/**
- * [Legacy] Convert 1e-9 to 0.000000001.
- * This may lose some precision if user really want 1e-9.
- */
-export function getNumberPrecision(number: string | number) {
-  const numStr = String(number)
-
-  if (isE(number)) {
-    let precision = Number(numStr.slice(numStr.indexOf('e-') + 2))
-
-    const decimalMatch = numStr.match(/\.(\d+)/)
-    if (decimalMatch?.[1]) {
-      precision += decimalMatch[1].length
-    }
-    return precision
-  }
-
-  return numStr.includes('.') && validateNumber(numStr)
-    ? numStr.length - numStr.indexOf('.') - 1
-    : 0
-}
-
-/**
- * Convert number (includes scientific notation) to -xxx.yyy format
- */
-export function num2str(number: number): string {
-  let numStr = String(number)
-  if (isE(number)) {
-    if (number > Number.MAX_SAFE_INTEGER) {
-      return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER)
-    }
-
-    if (number < Number.MIN_SAFE_INTEGER) {
-      return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER)
-    }
-
-    numStr = number.toFixed(getNumberPrecision(numStr))
-  }
-
-  return trimNumber(numStr).fullStr
-}
-
-export function validateNumber(num: string | number) {
-  if (typeof num === 'number') {
-    return !Number.isNaN(num)
-  }
-
-  // Empty
-  if (!num) {
-    return false
-  }
-
-  return (
-    // Normal type: 11.28
-    /^\s*-?\d+(\.\d+)?\s*$/.test(num) ||
-    // Pre-number: 1.
-    /^\s*-?\d+\.\s*$/.test(num) ||
-    // Post-number: .1
-    /^\s*-?\.\d+\s*$/.test(num)
-  )
-}

package/src/input-number/src/utils/supportUtil.ts

@@ -1,3 +0,0 @@
-export function supportBigInt() {
-  return typeof BigInt === 'function'
-}