@ledgerhq/live-common 34.46.0-nightly.4 → 34.46.0

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/getBalanceAndFiatValueByAssets.ts

@@ -1,76 +0,0 @@
-import { formatCurrencyUnit } from "@ledgerhq/coin-framework/lib-es/currencies/formatCurrencyUnit";
-import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
-import type { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
-import { groupAccountsByAsset, type GroupedAccount } from "./groupAccountsByAsset";
-import { AssetType } from "./type";
-import { AccountLike } from "@ledgerhq/types-live";
-import { counterValueFormatter } from "./counterValueFormatter";
-
-interface ExtendedAssetType extends AssetType {
-  balance?: string;
-  fiatValue?: string;
-}
-
-export const getBalanceAndFiatValueByAssets = (
-  accounts: AccountLike[],
-  assets: CryptoOrTokenCurrency[],
-  counterValuesState: CounterValuesState,
-  targetCurrency: Currency,
-  isDiscreetMode: boolean = false,
-  userLocale: string,
-): ExtendedAssetType[] => {
-  const groupedAccountsByAsset = groupAccountsByAsset(
-    accounts,
-    counterValuesState,
-    targetCurrency,
-    isDiscreetMode,
-  );
-
-  return assets.map(asset => {
-    const assetGroup = groupedAccountsByAsset[asset.id];
-
-    if (assetGroup) {
-      return formatAssetDetails(assetGroup, asset, targetCurrency, isDiscreetMode, userLocale);
-    }
-
-    return {
-      id: asset.id,
-      name: asset.name,
-      ticker: asset.ticker,
-    };
-  });
-};
-
-const formatAssetDetails = (
-  assetGroup: GroupedAccount,
-  asset: CryptoOrTokenCurrency,
-  targetCurrency: Currency,
-  isDiscreetMode: boolean,
-  userLocale: string,
-): ExtendedAssetType => {
-  const assetDetails =
-    assetGroup.accounts[0].type === "Account"
-      ? assetGroup.accounts[0].currency
-      : assetGroup.accounts[0].token;
-
-  const formattedBalance = formatCurrencyUnit(assetDetails.units[0], assetGroup.totalBalance, {
-    showCode: true,
-    discreet: isDiscreetMode,
-  });
-
-  const formattedFiatValue = counterValueFormatter({
-    currency: targetCurrency.ticker,
-    value: assetGroup.totalFiatValue.toNumber(),
-    locale: userLocale,
-    allowZeroValue: true,
-    discreetMode: isDiscreetMode,
-  });
-
-  return {
-    id: asset.id,
-    name: asset.name,
-    ticker: asset.ticker,
-    balance: formattedBalance,
-    fiatValue: formattedFiatValue,
-  };
-};

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/groupAccountsByAsset.ts

@@ -1,51 +0,0 @@
-import { getBalanceAndFiatValue } from "./getBalanceAndFiatValue";
-import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
-import { Currency } from "@ledgerhq/types-cryptoassets";
-import { AccountLike } from "@ledgerhq/types-live";
-import BigNumber from "bignumber.js";
-import { parseToBigNumber } from "./parseToBigNumber";
-
-export type GroupedAccount = {
-  totalBalance: BigNumber;
-  totalFiatValue: BigNumber;
-  accounts: AccountLike[];
-};
-
-export const groupAccountsByAsset = (
-  accounts: AccountLike[],
-  counterValuesState: CounterValuesState,
-  targetCurrency: Currency,
-  isDiscreetMode: boolean,
-): Record<string, GroupedAccount> => {
-  const initialGroupedAccounts: Record<string, GroupedAccount> = {};
-
-  return accounts.reduce((groupedAccounts, account) => {
-    const assetId = account.type === "Account" ? account.currency.id : account.token.id;
-
-    if (!groupedAccounts[assetId]) {
-      groupedAccounts[assetId] = {
-        totalBalance: new BigNumber(0),
-        totalFiatValue: new BigNumber(0),
-        accounts: [],
-      };
-    }
-
-    const { fiatValue } = getBalanceAndFiatValue(
-      account,
-      counterValuesState,
-      targetCurrency,
-      isDiscreetMode,
-      false,
-    );
-    const balance = account.balance;
-
-    const parsedFiatValue = parseToBigNumber(fiatValue ?? "0");
-
-    groupedAccounts[assetId].totalBalance = groupedAccounts[assetId].totalBalance.plus(balance);
-    groupedAccounts[assetId].totalFiatValue =
-      groupedAccounts[assetId].totalFiatValue.plus(parsedFiatValue);
-    groupedAccounts[assetId].accounts.push(account);
-
-    return groupedAccounts;
-  }, initialGroupedAccounts);
-};

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);
-};

package/src/modularDrawer/utils/type.ts

@@ -1,22 +0,0 @@
-export type AssetType = {
-  name: string;
-  ticker: string;
-  id: string;
-  leftElement?: React.ReactNode;
-  rightElement?: React.ReactNode;
-};
-
-export type ProviderBalanceAsset = {
-  id: string;
-  name: string;
-  ticker: string;
-  balance: string;
-  fiatValue: string;
-  sortValue: number;
-};
-
-export type ProviderBalanceResultsMap = Map<string, ProviderBalanceAsset>;
-
-export type AssetWithBalance = AssetType & {
-  sortValue?: number;
-};