@mezo-org/passport 0.5.2-dev.3 → 0.5.2-dev.4

package/src/utils/number2.ts

@@ -1,419 +0,0 @@
-// Matches floating point numbers with optional thousands separators
-export const FLOATING_POINT_REGEX = /^[^0-9]*([0-9,]+)(?:\.([0-9]*))?$/
-const FRIENDLY_DECIMALS_AMOUNT = 6
-
-type FixedPointNumber = {
-  amount: bigint
-  decimals: number
-}
-
-/**
- * HELPER FUNCTIONS
- * These functions are used to convert between floating-point numbers and fixed-point numbers.
- * They handle parsing, conversion, and formatting of numbers with specific decimal places.
- * They shouldn't be used directly in the UI or business logic.
- */
-
-/**
- * Parses a floating-point string into a fixed-point number representation.
- * @param floatingPointString The floating-point string to parse.
- * @returns The fixed-point number representation or undefined if parsing fails.
- */
-const parseToFixedPointNumber = (
-  floatingPointString: string,
-): FixedPointNumber | undefined => {
-  if (!floatingPointString.match(FLOATING_POINT_REGEX)) {
-    return undefined
-  }
-
-  const [whole, decimals, ...extra] = floatingPointString.split(".")
-
-  // Only one `.` supported.
-  if (extra.length > 0) {
-    return undefined
-  }
-
-  const noThousandsSeparatorWhole = whole.replace(",", "")
-  const setDecimals = decimals ?? ""
-
-  try {
-    return {
-      amount: BigInt([noThousandsSeparatorWhole, setDecimals].join("")),
-      decimals: setDecimals.length,
-    }
-  } catch (error) {
-    return undefined
-  }
-}
-
-/**
- * Separates thousands in a number with commas.
- * @param value The value to format.
- * @param minDecimals The minimum number of decimal places.
- * @param maxDecimals The maximum number of decimal places.
- * @returns The formatted value with thousands separators.
- */
-const separateThousandsWithComma = (
-  value: number | bigint | string,
-  minDecimals = 0,
-  maxDecimals = 2,
-): string => {
-  let adjustedValue = value
-  let adjustedMaxDecimals = maxDecimals
-
-  // If passed value is not numeric we should return 0
-  if (Number.isNaN(+value.toString())) {
-    adjustedValue = 0
-  }
-
-  if (typeof adjustedValue === "string") {
-    adjustedValue = +adjustedValue
-  }
-
-  if (minDecimals > maxDecimals) {
-    adjustedMaxDecimals = minDecimals
-  }
-
-  // Ensure maximumFractionDigits is within allowed range [0, 20]
-  const safeMaxDecimals = Math.max(0, Math.min(adjustedMaxDecimals, 20))
-
-  // @ts-expect-error - `maximumFractionDigits` wants to get number less than 21,
-  // but as the tokens have 18 decimals have, we can safely pass a parameter
-  return adjustedValue.toLocaleString("en-US", {
-    minimumFractionDigits: minDecimals,
-    maximumFractionDigits: safeMaxDecimals,
-    roundingMode: "halfExpand",
-  })
-}
-
-/** PUBLIC HELPER FUNCTIONS for calculations */
-
-/**
- * Multiplies a bigint with a decimal number, taking into account the decimal places.
- *
- * @param bigint - The bigint value to multiply.
- * @param number - The decimal number to multiply with.
- * @returns The result of the multiplication as a bigint.
- */
-export const multiplyBigIntWithDecimal = (
-  bigint: bigint,
-  number: number,
-): bigint => {
-  const numberString = number.toString()
-  const scientificMatch = /^1e-(\d+)$/.exec(numberString)
-
-  // Ensure we can correctly deal with scientific number expression
-  if (scientificMatch) {
-    const exponent = parseInt(scientificMatch[1], 10)
-    const scale = BigInt(10 ** exponent)
-
-    return (bigint * 1n) / scale
-  }
-
-  const decimalsPart = number.toString().split(".")[1]
-  const decimalsCount = decimalsPart ? decimalsPart.length : 0
-
-  if (!decimalsCount) return bigint * BigInt(number)
-
-  const scale = BigInt(10 ** decimalsCount)
-  const scaledNumber = BigInt(Math.round(number * Number(scale)))
-
-  return (bigint * scaledNumber) / scale
-}
-
-/**
- * Converts a fixed-point number to another fixed-point number with a different decimal precision.
- * @param args The arguments for the conversion.
- *  - amount: required, the fixed-point number to convert.
- *  - decimals: required, the current decimal precision of the number.
- *  - targetDecimals: required, the target decimal precision for the conversion.
- * @returns The converted fixed-point number.
- */
-export const convertDecimals = ({
-  amount,
-  decimals,
-  targetDecimals,
-}: {
-  amount: bigint
-  decimals: number
-  targetDecimals: number
-}): bigint => {
-  if (decimals >= targetDecimals) {
-    return amount / 10n ** BigInt(decimals - targetDecimals)
-  }
-
-  return amount * 10n ** BigInt(targetDecimals - decimals)
-}
-
-/** Helper functions for input components */
-
-/**
- * Trims decimal places to a specified precision - NO ROUNDING!
- * @param value The value to trim
- * @param precision The number of decimal places to keep
- * @returns The trimmed value
- */
-export const trimDecimals = (value: string, precision: number): string => {
-  const [integerPart, decimalPart = ""] = value.split(".")
-  return decimalPart.length > precision
-    ? `${integerPart}.${decimalPart.slice(0, precision)}`
-    : value
-}
-
-/**
- * Trims integer part to a specified length - NO ROUNDING!
- * @param value The value to trim
- * @param precision The number of integer places to keep
- * @returns The trimmed value
- * @deprecated just compare the value to the max allowed value in the input component
- */
-export const trimBeforeDecimals = (
-  value: string,
-  precision: number,
-): string => {
-  const [integerPart, decimalPart = ""] = value.split(".")
-
-  return integerPart.length > precision
-    ? `${integerPart.slice(0, precision)}.${decimalPart}`
-    : value
-}
-
-/**
- * Normalizes a decimal number input by removing invalid characters and preventing multiple dots.
- * @param value The value to normalize
- * @returns The normalized value
- */
-export const normalizeDecimalNumber = (value: string) =>
-  value.replace(/[^0-9.]/g, "").replace(/\.(?=.*\.)/g, "") // Remove all dots except the first one
-
-/**
- * CONVERSION FUNCTIONS
- * These functions convert between floating-point numbers and big integers as well as
- * provide human-readable formats.
- *
- * They are used to ensure that numbers are correctly formatted for display and calculations
- * and should be used in the UI and business logic to ensure correct number formatting.
- */
-
-/** Basic conversion bigint <-> float  */
-
-/**
- * Converts a floating-point number to a big integer representation.
- * @param args The arguments for the conversion.
- *   - amount: required, the floating-point number to convert.
- *   - decimals: optional, the number of decimal places to consider.
- * @returns The big integer representation of the floating-point number.
- */
-export const floatToBigInt = ({
-  amount,
-  decimals = 18,
-}: {
-  amount: string | number
-  decimals?: number
-}): bigint => {
-  const parsedAmount = amount.toString()
-  const fixedPointAmount = parseToFixedPointNumber(parsedAmount)
-
-  if (typeof fixedPointAmount === "undefined") {
-    return 0n
-  }
-
-  const bigIntAmount = convertDecimals({
-    amount: fixedPointAmount.amount,
-    decimals: fixedPointAmount.decimals,
-    targetDecimals: decimals,
-  })
-
-  return bigIntAmount
-}
-
-/**
- * Converts a big integer representation to a floating-point number.
- * @param args The arguments for the conversion.
- *   - amount: required, the big integer representation to convert.
- *   - decimals: optional, the number of decimal places to consider.
- *   - desiredDecimals: optional, the desired number of decimal places for the output.
- * @returns The floating-point representation of the big integer.
- */
-export const bigIntToFloat = ({
-  amount,
-  decimals = 18,
-  desiredDecimals = decimals,
-}: {
-  amount: bigint
-  decimals?: number
-  desiredDecimals?: number
-}): string => {
-  let isNegative = false
-  let normalizedAmount = amount
-
-  if (amount < 0n) {
-    normalizedAmount = -amount
-    isNegative = true
-  }
-
-  const desiredDecimalsAmount =
-    normalizedAmount / 10n ** BigInt(Math.max(0, decimals - desiredDecimals))
-
-  // Desired decimals amount with additional decimal to check if number
-  // should be rounded up
-  const desiredDecimalsAmountWithAdditionalDecimal =
-    normalizedAmount /
-    10n ** BigInt(Math.max(0, decimals - desiredDecimals - 1))
-
-  // We are getting the first value that has been cut off
-  const firstDecimalAfterCutOff = desiredDecimalsAmountWithAdditionalDecimal
-    .toString()
-    .at(-1)
-
-  // Padding amount when its length is smaller than desired
-  const parsedDesiredAmount = desiredDecimalsAmount
-    .toString()
-    .padStart(desiredDecimals + 1, "0")
-
-  const integersPart = parsedDesiredAmount.slice(0, -desiredDecimals)
-  const decimalsPart = parsedDesiredAmount.slice(-desiredDecimals)
-
-  // If number is above or equal to 5 we should round up the number
-  const shouldIncreaseDecimalsPart =
-    Number(firstDecimalAfterCutOff) >= 5 && desiredDecimals !== decimals
-
-  // If above is true we add 1 to the decimals value and convert it back to string
-  const adjustedDecimalsPart = shouldIncreaseDecimalsPart
-    ? (Number(decimalsPart) + 1).toString().padStart(desiredDecimals, "0")
-    : decimalsPart
-
-  // Determining whether integer part needs to be increased due to rounding up
-  const shouldIncreaseIntegerPart =
-    (decimalsPart === "0" && adjustedDecimalsPart !== decimalsPart) ||
-    adjustedDecimalsPart.length > decimalsPart.length
-
-  // If above is true we add 1 to the integers value and convert it back to string
-  // and set first value of decimals part to 0
-  const adjustedIntegersPart = shouldIncreaseIntegerPart
-    ? (Number(integersPart) + 1).toString()
-    : integersPart
-
-  const decimalsPartAfterIntegersAdjustments = shouldIncreaseIntegerPart
-    ? `0${adjustedDecimalsPart.slice(1)}`
-    : adjustedDecimalsPart
-
-  // Inserting "." to separate integers part from decimal part
-  const desiredAmount = [
-    ...adjustedIntegersPart,
-    ".",
-    ...decimalsPartAfterIntegersAdjustments,
-  ].join("")
-
-  // Remove trailing zeros and the trailing decimal point (if exists)
-  const trimmedDesiredAmount = desiredAmount.replace(
-    /(?:\.0*|(\.\d+?)0+)$/,
-    "$1",
-  )
-
-  return isNegative ? `-${trimmedDesiredAmount}` : trimmedDesiredAmount
-}
-
-/**  Human-readable formats */
-
-type AmountAsHumanReadableArguments<T extends number | string | bigint> = {
-  amount: T
-  desiredDecimals?: number
-  minDecimals?: number
-  decimals?: number
-}
-
-/**
- * Helpers for setting correct arguments and getting unified human-readable
- * formats across the app with _toHumanReadableFormat functions.
- */
-
-export const amountAsUSD = <T extends number | string | bigint>(
-  args: AmountAsHumanReadableArguments<T>,
-): AmountAsHumanReadableArguments<T> => ({
-  desiredDecimals: 2,
-  minDecimals: 2,
-  ...args,
-})
-
-export const amountAsToken = <T extends number | string | bigint>(
-  args: AmountAsHumanReadableArguments<T>,
-): AmountAsHumanReadableArguments<T> => ({
-  desiredDecimals: FRIENDLY_DECIMALS_AMOUNT,
-  minDecimals: 0,
-  ...args,
-})
-
-export const amountAsMusd = <T extends number | string | bigint>(
-  args: AmountAsHumanReadableArguments<T>,
-): AmountAsHumanReadableArguments<T> => ({
-  desiredDecimals: 2,
-  minDecimals: 2,
-  decimals: 18, // MUSD has 18 decimals
-  ...args,
-})
-
-export const amountAsMats = <T extends number | string | bigint>(
-  args: AmountAsHumanReadableArguments<T>,
-): AmountAsHumanReadableArguments<T> => ({
-  desiredDecimals: 0,
-  minDecimals: 0,
-  ...args,
-})
-
-/**
- * Converts a floating-point number to a human-readable format - with thousands
- * separators and specified decimal places.
- * @param args The arguments for the conversion.
- *   - amount: required, the floating-point number to convert.
- *   - desiredDecimals: optional, the desired number of decimal places for the output.
- *   - minDecimals: optional, the minimum number of decimal places.
- * @returns The human-readable format of the floating-point number.
- */
-export const floatToHumanReadableFormat = ({
-  amount,
-  desiredDecimals = 2, // treat is as an USD amount by default
-  minDecimals = 0,
-}: AmountAsHumanReadableArguments<number | string>): string =>
-  separateThousandsWithComma(amount, minDecimals, desiredDecimals)
-
-export const bigIntToHumanReadableFormat = ({
-  amount,
-  decimals = 18,
-  desiredDecimals = FRIENDLY_DECIMALS_AMOUNT, // treat is as a token by default
-  minDecimals = 0,
-}: AmountAsHumanReadableArguments<bigint>): string => {
-  let isNegative = false
-  let normalizedAmount = amount
-  let adjustedDesiredDecimals = desiredDecimals
-
-  if (minDecimals > desiredDecimals) {
-    adjustedDesiredDecimals = minDecimals
-  }
-
-  if (normalizedAmount < 0n) {
-    normalizedAmount = -normalizedAmount
-    isNegative = true
-  }
-
-  const trimmedDesiredAmount = bigIntToFloat({
-    amount: normalizedAmount,
-    decimals,
-    desiredDecimals: adjustedDesiredDecimals,
-  })
-
-  if (trimmedDesiredAmount === "0" && normalizedAmount !== 0n) {
-    const decimalsString = "1".padStart(adjustedDesiredDecimals, "0")
-    return `<0.${decimalsString}`
-  }
-
-  const desiredValue = isNegative
-    ? `-${trimmedDesiredAmount}`
-    : trimmedDesiredAmount
-
-  return floatToHumanReadableFormat({
-    amount: desiredValue,
-    desiredDecimals: adjustedDesiredDecimals,
-    minDecimals,
-  })
-}