@lfsoftwares/native-util 0.0.2

package/src/NumberUtils/util.numbers.ts

@@ -0,0 +1,250 @@
+import { Platform } from 'react-native'
+import { formatCurrency } from 'react-native-format-currency'
+
+class NumberUtils {
+  static stringToFloat(textValue?: string) {
+    if (textValue) {
+      textValue = textValue
+        .replace('R$', '')
+        .replace('%', '')
+        .replace('.', '')
+        .replace(',', '.')
+        .trim()
+
+      if (textValue.includes('(')) {
+        textValue = textValue.split('(')[0].trim()
+      }
+
+      return parseFloat(textValue)
+    } else {
+      return NaN
+    }
+  }
+
+  static editFloatString(textValue?: string) {
+    if (textValue) {
+      textValue = textValue
+        .replace('R$', '')
+        .replace('%', '')
+        .replace('.', '')
+        .trim()
+
+      if (textValue.includes('(')) {
+        textValue = textValue.split('(')[0].trim()
+      }
+
+      return textValue
+    } else {
+      return ''
+    }
+  }
+
+  static currencyFormat(
+    currencyValue: number | string | undefined,
+    putSymbol = false,
+    putPercent = false,
+    outMultiple = 0,
+    decimals = 2,
+  ) {
+    try {
+      let currencyNumber: number
+
+      if (!currencyValue) {
+        currencyValue = 0
+      }
+
+      if (typeof currencyValue === 'string') {
+        currencyNumber = parseFloat(
+          currencyValue
+            .replace('R$', '')
+            .replace('%', '')
+            .replace('.', '')
+            .replace(',', '.')
+            .trim(),
+        )
+      } else {
+        currencyNumber = currencyValue
+      }
+
+      if (isNaN(currencyNumber)) {
+        currencyNumber = 0
+      }
+
+      if (Platform.OS === 'ios') {
+        let currencyText = new Intl.NumberFormat('pt-BR', {
+          style: 'currency',
+          currency: 'BRL',
+          maximumFractionDigits: decimals,
+        }).format(currencyNumber)
+
+        if (putPercent) {
+          currencyText = currencyText.replace('R$', '').trim() + '%'
+        } else if (!putSymbol) {
+          currencyText = currencyText.replace('R$', '').trim()
+        }
+
+        if (outMultiple > 0) {
+          if (currencyText.includes(',')) {
+            if (outMultiple === 1 || parseInt(currencyText.split(',')[1]) === 0)
+              currencyText = currencyText.split(',')[0]
+          }
+        }
+
+        return currencyText
+      } else {
+        currencyNumber = parseFloat(currencyNumber.toFixed(decimals))
+
+        const [currencyTextWithSymbol, currencyTextWithoutSymbol] =
+          formatCurrency({
+            amount: currencyNumber,
+            code: 'BRL',
+          })
+
+        const currencyParts = putSymbol
+          ? currencyTextWithSymbol.split(',')
+          : String(currencyTextWithoutSymbol).split(',')
+
+        let decimal = ',' + '0'.repeat(decimals)
+
+        if (currencyParts[1]) {
+          decimal = ',' + currencyParts[1].padEnd(decimals, '0')
+        }
+
+        if (
+          outMultiple === 1 ||
+          (outMultiple > 0 && parseInt(decimal.replace(',', '')) === 0)
+        ) {
+          return currencyParts[0]
+        }
+
+        if (!putSymbol && putPercent) {
+          decimal += '%'
+        }
+
+        return currencyParts[0] + decimal
+      }
+    } catch {
+      return String(currencyValue)
+    }
+  }
+
+  static extractCurrencyValue(currencyText: string) {
+    if (currencyText.length > 0) {
+      const currencyValue = parseFloat(
+        currencyText
+          .replace('R$', '')
+          .replace('%', '')
+          .replace('.', '')
+          .replace(',', '.')
+          .trim(),
+      )
+      return isNaN(currencyValue) ? 0 : currencyValue
+    } else {
+      return 0
+    }
+  }
+
+  static extractNumbers(text: string, includeComma?: boolean) {
+    const characters = '0123456789' + (includeComma ? ',' : '')
+
+    function check(x: string) {
+      return !!characters.includes(x)
+    }
+    return [...text].reduce((x, y) => (check(y) ? x + y : x), '')
+  }
+
+  static numbersAndDots(text: string) {
+    const characters = '0123456789.'
+
+    function check(x: string) {
+      return !!characters.includes(x)
+    }
+    return [...text].reduce((x, y) => (check(y) ? x + y : x), '')
+  }
+
+  static stringToInteger(text?: string) {
+    if (!text) {
+      return 0
+    }
+
+    try {
+      text = this.extractNumbers(text)
+
+      if (!isNaN(parseInt(text))) {
+        return parseInt(text)
+      } else {
+        return 0
+      }
+    } catch {
+      return 0
+    }
+  }
+
+  static formatDecimalValue(decimalText: string, putSymbol: boolean) {
+    const formatedText = decimalText.replace('.', '').replace(',', '')
+
+    if (formatedText.length === 1) {
+      return putSymbol ? 'R$ 0,0' + formatedText : '0,0' + formatedText
+    }
+    if (formatedText.length === 2) {
+      return putSymbol ? 'R$ 0,' + formatedText : '0,' + formatedText
+    }
+
+    let valueText = ''
+    let digits = 0
+
+    for (let i = formatedText.length - 1; i >= 0; i--) {
+      if (valueText.length === 2) {
+        valueText = formatedText[i] + ',' + valueText
+        digits += 1
+      } else if (valueText.length > 2) {
+        if (digits === 3) {
+          digits = 1
+          valueText = formatedText[i] + '.' + valueText
+        } else {
+          valueText = formatedText[i] + valueText
+          digits += 1
+        }
+      } else {
+        valueText = formatedText[i] + valueText
+      }
+    }
+
+    return putSymbol ? 'R$ ' + valueText : valueText
+  }
+
+  static truncValue(value: number) {
+    if (value > 0) {
+      const textValue = String(value)
+      if (textValue.includes('.')) {
+        const numberParts = textValue.split('.')
+        const integerPart = numberParts[0]
+        const decimalPart = numberParts[1].substring(0, 2).padEnd(2, '0')
+
+        const trucatedNumber = parseFloat(integerPart + '.' + decimalPart)
+
+        if (!isNaN(trucatedNumber)) {
+          return trucatedNumber
+        } else {
+          return value
+        }
+      } else {
+        return value
+      }
+    } else {
+      return 0
+    }
+  }
+
+  static roundValue(value: number, decimalPlaces: number) {
+    return parseFloat(value.toFixed(decimalPlaces))
+  }
+
+  static roundValueStr(value: number, decimalPlaces: number) {
+    const roundedValue = this.roundValue(value, decimalPlaces)
+
+    return roundedValue.toFixed(decimalPlaces)
+  }
+}
+
+export default NumberUtils

package/src/RegexConsts/consts.regex.ts

@@ -0,0 +1,10 @@
+const RNRegex = {
+  REGEX_IP: /^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)(?:\.(?!$)|$)){4}$/,
+  REGEX_URL: /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})(\/[\w]*)*$/,
+  REGEX_EMAIL:
+    /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+  REGEX_PHONE:
+    /^(\+55)?[\s]?\(?(\d{2})?\)?[\s-]?(9?\d{4}[\s-]?\d{4})$/
+}
+
+export default RNRegex

package/src/RegexConsts/index.ts

@@ -0,0 +1 @@
+export { default } from './consts.regex'

package/src/ValidationUtils/index.ts

@@ -0,0 +1 @@
+export { default } from './util.validation'

package/src/ValidationUtils/util.validation.ts

@@ -0,0 +1,215 @@
+import GeneralConsts from "../GeneralConsts"
+import NumberUtils from "../NumberUtils"
+import RegexConsts from "../RegexConsts"
+
+class ValidationUtils {
+  static validateCNPJ(cnpj?: string) {
+    if (!cnpj) {
+      return ''
+    }
+
+    cnpj = cnpj.replace(/[^\d]+/g, '')
+
+    if (cnpj.length !== 14) return ''
+
+    if (
+      cnpj === '00000000000000' ||
+      cnpj === '11111111111111' ||
+      cnpj === '22222222222222' ||
+      cnpj === '33333333333333' ||
+      cnpj === '44444444444444' ||
+      cnpj === '55555555555555' ||
+      cnpj === '66666666666666' ||
+      cnpj === '77777777777777' ||
+      cnpj === '88888888888888' ||
+      cnpj === '99999999999999'
+    )
+      return ''
+
+    let tamanho: number = cnpj.length - 2
+    let numeros: string = cnpj.substring(0, tamanho)
+    const digitos: string = cnpj.substring(tamanho)
+    let soma = 0
+    let pos = tamanho - 7
+
+    for (let i = tamanho; i >= 1; i--) {
+      soma += parseInt(numeros.charAt(tamanho - i)) * pos--
+      if (pos < 2) pos = 9
+    }
+
+    let resultado: number = soma % 11 < 2 ? 0 : 11 - (soma % 11)
+
+    if (resultado !== parseInt(digitos.charAt(0))) return ''
+
+    tamanho += 1
+    numeros = cnpj.substring(0, tamanho)
+    soma = 0
+    pos = tamanho - 7
+
+    for (let i = tamanho; i >= 1; i--) {
+      soma += parseInt(numeros.charAt(tamanho - i)) * pos--
+      if (pos < 2) {
+        pos = 9
+      }
+    }
+
+    resultado = soma % 11 < 2 ? 0 : 11 - (soma % 11)
+
+    if (resultado !== parseInt(digitos.charAt(1))) return ''
+
+    return (
+      cnpj.substring(0, 2) +
+      '.' +
+      cnpj.substring(2, 5) +
+      '.' +
+      cnpj.substring(5, 8) +
+      '/' +
+      cnpj.substring(8, 12) +
+      '-' +
+      cnpj.substring(12, 14)
+    )
+  }
+
+  static validateCPF(cpf?: string) {
+    if (!cpf) {
+      return ''
+    }
+
+    cpf = cpf.replace(/[^\d]+/g, '')
+
+    if (cpf.length !== 11) return ''
+
+    if (
+      cpf === '00000000000' ||
+      cpf === '11111111111' ||
+      cpf === '22222222222' ||
+      cpf === '33333333333' ||
+      cpf === '44444444444' ||
+      cpf === '55555555555' ||
+      cpf === '66666666666' ||
+      cpf === '77777777777' ||
+      cpf === '88888888888' ||
+      cpf === '99999999999'
+    )
+      return ''
+
+    let soma = 0
+    let resto
+
+    for (let i = 1; i <= 9; i++)
+      soma = soma + parseInt(cpf.substring(i - 1, i)) * (11 - i)
+    resto = (soma * 10) % 11
+
+    if (resto === 10 || resto === 11) resto = 0
+    if (resto !== parseInt(cpf.substring(9, 10))) return ''
+
+    soma = 0
+    for (let i = 1; i <= 10; i++)
+      soma = soma + parseInt(cpf.substring(i - 1, i)) * (12 - i)
+    resto = (soma * 10) % 11
+
+    if (resto === 10 || resto === 11) resto = 0
+    if (resto !== parseInt(cpf.substring(10, 11))) return ''
+
+    return (
+      cpf.substring(0, 3) +
+      '.' +
+      cpf.substring(3, 6) +
+      '.' +
+      cpf.substring(6, 9) +
+      '-' +
+      cpf.substring(9, 11)
+    )
+  }
+
+  static validateEmail(email?: string) {
+    if (!email) {
+      return ''
+    }
+
+    return RegexConsts.REGEX_EMAIL.test(email)
+  }
+
+  static validatePhoneNumber(
+    phoneNumber?: string,
+    forceNineDigits?: boolean,
+  ) {
+    if (!phoneNumber) {
+      return ''
+    }
+
+    let phone = NumberUtils.extractNumbers(phoneNumber)
+
+    if (forceNineDigits && phone.length === 12) {
+      phone = phone.slice(0, 4) + '9' + phone.slice(4)
+    } else if (forceNineDigits && phone.length === 10) {
+      phone = phone.slice(0, 2) + '9' + phone.slice(2)
+    } else if (forceNineDigits && phone.length === 8) {
+      phone = '9' + phone
+    }
+
+    if (phone.length === 13) {
+      return (
+        '(' +
+        phone.substring(2, 4) +
+        ') ' +
+        phone.substring(4, 9) +
+        '-' +
+        phone.substring(9)
+      )
+    }
+
+    if (phone.length < 8 || phone.length > 11) {
+      return ''
+    }
+
+    let numbers = ''
+
+    if (phone.length > 9) {
+      const ddd = phone.substring(0, 2)
+
+      if (!GeneralConsts.DDD_BRASIL.includes(ddd)) {
+        return ''
+      }
+
+      numbers = phone.substring(2)
+    } else {
+      numbers = phone
+    }
+
+    if (numbers === '00000000' || numbers === '000000000') return ''
+
+    const isValid = RegexConsts.REGEX_PHONE.test(phone)
+
+    if (isValid) {
+      switch (phone.length) {
+        case 8:
+          return phone.substring(0, 4) + '-' + phone.substring(4)
+        case 9:
+          return phone.substring(0, 5) + '-' + phone.substring(5)
+        case 10:
+          return (
+            '(' +
+            phone.substring(0, 2) +
+            ')' +
+            phone.substring(2, 6) +
+            '-' +
+            phone.substring(6)
+          )
+        default:
+          return (
+            '(' +
+            phone.substring(0, 2) +
+            ')' +
+            phone.substring(2, 7) +
+            '-' +
+            phone.substring(7)
+          )
+      }
+    } else {
+      return ''
+    }
+  }
+}
+
+export default ValidationUtils

package/src/index.ts

@@ -0,0 +1,9 @@
+export { default as RNGeneralConsts } from './GeneralConsts'
+export { default as RNRegexConsts } from './RegexConsts'
+export { default as RNDateUtils } from './DateUtils'
+export { default as RNFormatUtils } from './FormatUtils'
+export { default as RNGeneralUtils } from './GeneralUtils'
+export { default as RNMaskUtils } from './MaskUtils'
+export { default as RNNetworkUtils } from './NetworkUtils'
+export { default as RNNumberUtils } from './NumberUtils'
+export { default as RNValidationUtils } from './ValidationUtils'

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "jsx": "react-native",
+    "target": "ESNext",                                  
+    "module": "ESNext",                                
+    "declaration": true,                            
+    "declarationDir": "lib/types",
+    "sourceMap": true,                              
+    "outDir": "lib",                                
+    "moduleResolution": "node",                     
+    "allowSyntheticDefaultImports": true,
+    "lib": ["DOM", "ESNext"],                            
+    "resolveJsonModule": true,                      
+    "allowJs": true,                                
+    "declarationMap": true,                         
+    "noEmit": false,                                 
+    "esModuleInterop": true,                        
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,           
+    "skipLibCheck": true
+  },
+  "exclude": ["lib", "node_modules", "babel.config.js", "metro.config.js"]
+}