@ledgerhq/live-common 34.50.0 → 34.51.0-nightly.1

package/src/modularDrawer/utils/counterValueFormatter.ts

@@ -1,165 +0,0 @@
-import { rangeDataTable } from "../../market/utils/rangeDataTable";
-import { TFunction } from "i18next";
-
-export const RANGES = Object.keys(rangeDataTable).filter(key => key !== "1h");
-
-const indexes: [string, number][] = [
-  ["d", 1],
-  ["K", 1000],
-  ["M", 1000000],
-  ["B", 1000000000],
-  ["T", 1000000000000],
-  ["Q", 1000000000000000],
-  ["Qn", 1000000000000000000],
-];
-
-const formatters: Record<string, { [key: string]: Intl.NumberFormat }> = {};
-
-const getSanitizedValue = (currency: string | undefined, locale: string): string => {
-  if (currency) {
-    return `${formatters[locale][currency]
-      ?.format(0)
-      .replace(/[0-9,.]+/, "***")
-      .trim()}`;
-  }
-  return "***";
-};
-
-const shouldReturnDash = (
-  value: number,
-  allowZeroValue: boolean,
-  discreetMode: boolean,
-): boolean => {
-  return !discreetMode && (isNaN(value) || (!value && !allowZeroValue));
-};
-
-const ensureFormatterExists = (
-  locale: string,
-  currency: string | undefined,
-  decimalPlaces: number,
-): void => {
-  if (!formatters[locale]) formatters[locale] = {};
-
-  if (currency && !formatters[locale]?.[currency]) {
-    createCurrencyFormatter(locale, currency, decimalPlaces);
-  } else if (!currency && !formatters[locale]?.[`decimal_${decimalPlaces}`]) {
-    createDecimalFormatter(locale, decimalPlaces);
-  }
-};
-
-const createCurrencyFormatter = (locale: string, currency: string, decimalPlaces: number): void => {
-  try {
-    formatters[locale][currency] = new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency,
-    });
-  } catch {
-    formatters[locale][currency] = new Intl.NumberFormat(locale, {
-      style: "decimal",
-      minimumFractionDigits: decimalPlaces,
-      maximumFractionDigits: 8,
-    });
-  }
-};
-
-const createDecimalFormatter = (locale: string, decimalPlaces: number): void => {
-  formatters[locale][`decimal_${decimalPlaces}`] = new Intl.NumberFormat(locale, {
-    style: "decimal",
-    minimumFractionDigits: decimalPlaces,
-    maximumFractionDigits: decimalPlaces,
-  });
-};
-
-const getFormatter = (
-  currency: string | undefined,
-  locale: string,
-  shorten: boolean | undefined,
-  decimalPlaces: number,
-): Intl.NumberFormat | undefined => {
-  if (currency) {
-    return formatters[locale][currency];
-  }
-
-  if (shorten) {
-    return new Intl.NumberFormat(locale, {
-      notation: "compact",
-      maximumFractionDigits: 3,
-      minimumFractionDigits: Math.min(decimalPlaces, 3),
-    });
-  }
-
-  return formatters[locale][`decimal_${decimalPlaces}`];
-};
-
-const formatShortenedValue = (
-  value: number,
-  formatter: Intl.NumberFormat,
-  t: TFunction,
-): string => {
-  const sign = value > 0 ? "" : "-";
-  const v = Math.abs(value);
-  const index = Math.floor(Math.log10(v) / 3) || 0;
-  const [i, n] = indexes[index] || ["", 1];
-  const roundedValue = Math.round((v / n) * 1000) / 1000;
-  const number = formatter.format(roundedValue);
-  const I = t(`numberCompactNotation.${i}`);
-  const formattedNumber = number.replace(/([0-9,. ]+)/, `${sign}$1 ${I}`);
-  return formattedNumber.trim();
-};
-
-const formatRegularValue = (
-  value: number,
-  formatter: Intl.NumberFormat,
-  ticker: string,
-  currency: string | undefined,
-  locale: string,
-  discreetMode: boolean,
-): string => {
-  if (discreetMode) {
-    return getSanitizedValue(currency, locale);
-  }
-
-  const formattedValue = formatter.format(value);
-  const upperCaseTicker = ticker?.trim()?.toLocaleUpperCase();
-  return `${formattedValue} ${upperCaseTicker}`.trim();
-};
-
-export const counterValueFormatter = ({
-  currency,
-  value,
-  shorten,
-  locale,
-  t,
-  allowZeroValue = false,
-  ticker = "",
-  discreetMode = false,
-  decimalPlaces = 2,
-}: {
-  currency?: string;
-  value: number;
-  shorten?: boolean;
-  locale: string;
-  t?: TFunction;
-  allowZeroValue?: boolean;
-  ticker?: string;
-  discreetMode?: boolean;
-  decimalPlaces?: number;
-}): string => {
-  if (shouldReturnDash(value, allowZeroValue, discreetMode)) {
-    return "-";
-  }
-
-  ensureFormatterExists(locale, currency, decimalPlaces);
-
-  const formatter = getFormatter(currency, locale, shorten, decimalPlaces);
-
-  if (!formatter) {
-    return String(value);
-  }
-
-  if (shorten && t) {
-    return formatShortenedValue(value, formatter, t);
-  }
-
-  return formatRegularValue(value, formatter, ticker, currency, locale, discreetMode);
-};

package/src/modularDrawer/utils/getBalanceAndFiatValue.ts

@@ -1,53 +0,0 @@
-import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
-import { isAccount } from "@ledgerhq/coin-framework/account/helpers";
-import {
-  getPortfolioCount,
-  getBalanceHistoryWithCountervalue,
-} from "@ledgerhq/live-countervalues/portfolio";
-import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
-import { Currency } from "@ledgerhq/types-cryptoassets";
-import { Account, TokenAccount } from "@ledgerhq/types-live";
-import BigNumber from "bignumber.js";
-
-/**
- *
- * @param account - The account to get the balance and fiat value for
- * @param state - The current state of countervalues
- * @param toCurrency - The currency to convert to
- * @param discreet - Whether to show the balance in discreet mode
- * @param showCode - Whether to show the currency code in the formatted balance
- * @returns An object containing the balance and fiat value
- */
-export const getBalanceAndFiatValue = (
-  account: Account | TokenAccount,
-  state: CounterValuesState,
-  toCurrency: Currency,
-  discreet: boolean = false,
-  showCode: boolean = true,
-) => {
-  const isAnAccount = isAccount(account);
-  const details = isAnAccount ? account.currency : account.token;
-  const balance = formatCurrencyUnit(details.units[0], account.balance, {
-    showCode,
-    discreet,
-  });
-
-  const count = getPortfolioCount([account], "day");
-  const { history, countervalueAvailable } = getBalanceHistoryWithCountervalue(
-    account,
-    "day",
-    count,
-    state,
-    toCurrency,
-  );
-
-  if (!countervalueAvailable) return { balance, fiatValue: undefined };
-
-  const { countervalue } = history[history.length - 1] ?? {};
-  const fiatValue = formatCurrencyUnit(toCurrency.units[0], BigNumber(countervalue ?? 0), {
-    showCode,
-    discreet,
-  });
-
-  return { balance, fiatValue };
-};

package/src/modularDrawer/utils/getProviderCurrency.ts

@@ -1,13 +0,0 @@
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { getTokenOrCryptoCurrencyById } from "../../deposit/helper";
-
-export const getProviderCurrency = (
-  mainCurrency: CryptoOrTokenCurrency,
-  currencies: CryptoOrTokenCurrency[],
-) => {
-  try {
-    return getTokenOrCryptoCurrencyById(mainCurrency.id);
-  } catch {
-    return getTokenOrCryptoCurrencyById(currencies[0].id);
-  }
-};

package/src/modularDrawer/utils/haveOneCommonProvider.ts

@@ -1,31 +0,0 @@
-import { CurrenciesByProviderId } from "../../deposit/type";
-
-/**
- * This function checks if all currencies in the provided array
- * it stopped at the first currency that does not match to prevent unnecessary iterations.
- *
- * @param currenciesIdsArray array of currency IDs to check
- * @param currenciesByProvider array of currencies grouped by provider
- * @returns boolean indicating whether all currencies in the array have one common provider
- */
-export const haveOneCommonProvider = (
-  currenciesIdsArray: string[],
-  currenciesByProvider: CurrenciesByProviderId[],
-): boolean => {
-  if (currenciesIdsArray.length === 0) return false;
-
-  const providerIds = new Set<string>();
-
-  for (const currencyId of currenciesIdsArray) {
-    for (const provider of currenciesByProvider) {
-      if (provider.currenciesByNetwork.some(currency => currency.id === currencyId)) {
-        providerIds.add(provider.providerId);
-        if (providerIds.size > 1) {
-          return false;
-        }
-      }
-    }
-  }
-
-  return true;
-};

package/src/modularDrawer/utils/parseToBigNumber.ts

@@ -1,17 +0,0 @@
-import BigNumber from "bignumber.js";
-
-/**
- *
- * @param value - The value to parse into a BigNumber. It can be a string, number, or an existing BigNumber instance.
- * @template T - The type of the value, which can be string, number, or BigNumber.
- * @returns  A BigNumber instance representing the parsed value.
- */
-export const parseToBigNumber = <T extends string | number | BigNumber>(value: T): BigNumber => {
-  if (value instanceof BigNumber) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return new BigNumber(value.replace(/,/g, ""));
-  }
-  return new BigNumber(value);
-};