@unisat/wallet-state 1.0.5 → 1.2.0

package/src/context/I18nContext.tsx

@@ -1,23 +1,15 @@
+import { FALLBACK_LOCALE } from '@unisat/wallet-shared'
 import log from 'loglevel'
-import React, { createContext, useEffect, useState } from 'react'
+import React, { createContext, useContext, useEffect, useState } from 'react'
 
-import {
-  BROWSER_TO_APP_LOCALE_MAP,
-  changeLanguage,
-  FALLBACK_LOCALE,
-  getSupportedLocales,
-  initI18n,
-  LOCALE_NAMES,
-  t as translate,
-} from '@unisat/i18n'
-import { useWallet } from './WalletContext'
-
-interface I18nContextType {
-  t: (key: string, substitutions?: string | string[]) => string
+export interface I18nContextType {
+  t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string
   locale: string
   supportedLocales: string[]
   localeNames: Record<string, string>
   changeLocale: (locale: string) => Promise<void>
+  addResourceBundle?: (locale: string) => Promise<void>
+  isSpecialLocale: boolean
 }
 
 // Create context
@@ -26,166 +18,16 @@ export const I18nContext = createContext<I18nContextType>({
   locale: FALLBACK_LOCALE,
   supportedLocales: [],
   localeNames: {},
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
   changeLocale: async () => {},
+  addResourceBundle: async () => {},
+  isSpecialLocale: false,
 })
 
-// Context provider component
-export const I18nProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
-  const [locale, setLocale] = useState<string>(FALLBACK_LOCALE)
-  const [isInitialized, setIsInitialized] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
-  const wallet = useWallet()
-
-  // Initialize i18n
-  useEffect(() => {
-    const initialize = async () => {
-      try {
-        let localeToUse = FALLBACK_LOCALE
-        // @ts-ignore
-        const userSelectedLanguage = localStorage.getItem('userSelectedLanguage') === 'true'
-
-        if (userSelectedLanguage) {
-          // @ts-ignore
-          const savedLocale = localStorage.getItem('i18nextLng')
-          if (savedLocale && getSupportedLocales().includes(savedLocale)) {
-            localeToUse = savedLocale
-            log.debug(`Using user selected language: ${savedLocale}`)
-          }
-        } else {
-          try {
-            const isFirstOpen = await wallet.getIsFirstOpen()
-
-            if (isFirstOpen) {
-              // @ts-ignore
-              const browserLang = navigator.language
-              log.debug(`New user - Browser language: ${browserLang}`)
-
-              const mappedLocale = BROWSER_TO_APP_LOCALE_MAP[browserLang]
-              if (mappedLocale && getSupportedLocales().includes(mappedLocale)) {
-                localeToUse = mappedLocale
-                log.debug(`Using mapped browser language: ${mappedLocale}`)
-              } else if (getSupportedLocales().includes(browserLang)) {
-                localeToUse = browserLang
-                log.debug(`Using browser language: ${browserLang}`)
-              } else {
-                const mainLang = browserLang.split('-')[0]
-                if (getSupportedLocales().includes(mainLang)) {
-                  localeToUse = mainLang
-                  log.debug(`Using browser main language: ${mainLang}`)
-                } else {
-                  log.debug(`Browser language not supported, using default: ${FALLBACK_LOCALE}`)
-                  localeToUse = FALLBACK_LOCALE
-                }
-              }
-            } else {
-              log.debug('Existing user - Using default English')
-              localeToUse = FALLBACK_LOCALE
-            }
-          } catch (error) {
-            log.error('Failed to get user status, using default language:', error)
-            localeToUse = FALLBACK_LOCALE
-          }
-        }
-
-        // @ts-ignore
-        localStorage.setItem('i18nextLng', localeToUse)
-        await initI18n(localeToUse)
-
-        chrome.storage.local.set({ i18nextLng: localeToUse })
-        await initI18n(localeToUse)
-        // const currentLocale = await getCurrentLocale();
-
-        // setLocale(currentLocale);
-        setIsInitialized(true)
-      } catch (error) {
-        log.error('Failed to initialize i18n:', error)
-
-        setLocale(FALLBACK_LOCALE)
-        setIsInitialized(true)
-        setError(error instanceof Error ? error : new Error('Unknown error'))
-      }
-    }
-
-    initialize()
-  }, [wallet])
-
-  // Change language
-  const changeLocale = async (newLocale: string) => {
-    try {
-      await changeLanguage(newLocale)
-      setLocale(newLocale)
-      // @ts-ignore
-      localStorage.setItem('userSelectedLanguage', 'true')
-      // @ts-ignore
-      localStorage.setItem('i18nextLng', newLocale)
-      chrome.storage.local.set({ i18nextLng: newLocale })
-    } catch (error) {
-      setError(error instanceof Error ? error : new Error('Unknown error'))
-    }
+export function useI18n() {
+  const context = useContext(I18nContext)
+  if (!context) {
+    throw Error('Feature flag hooks can only be used by children of BridgeProvider.')
+  } else {
+    return context
   }
-
-  // Translation function
-  const t = (key: string, substitutions?: string | string[]) => {
-    try {
-      return translate(key, substitutions)
-    } catch (error) {
-      log.error(`Translation error for key "${key}":`, error)
-      return key
-    }
-  }
-
-  // If not yet initialized, show loading
-  if (!isInitialized) {
-    return (
-      <div
-        style={{
-          display: 'flex',
-          flexDirection: 'column',
-          width: '100vw',
-          height: '100vh',
-          overflowY: 'auto',
-          overflowX: 'hidden',
-        }}
-      >
-        <div
-          style={{
-            display: 'flex',
-            flex: 1,
-            flexDirection: 'column',
-            justifyItems: 'center',
-            alignItems: 'center',
-          }}
-        >
-          <div />
-        </div>
-      </div>
-    )
-  }
-
-  // If there is an error, show error message in development environment
-  // @ts-ignore
-  if (error && process.env.NODE_ENV === 'development') {
-    return (
-      <div style={{ color: 'red', padding: '20px' }}>
-        <h2>Error initializing i18n</h2>
-        <p>{error.message}</p>
-        <pre>{error.stack}</pre>
-      </div>
-    )
-  }
-
-  return (
-    <I18nContext.Provider
-      value={{
-        t,
-        locale,
-        supportedLocales: getSupportedLocales(),
-        localeNames: LOCALE_NAMES,
-        changeLocale,
-      }}
-    >
-      {children}
-    </I18nContext.Provider>
-  )
 }

package/src/context/NavigationContext.tsx

@@ -0,0 +1,305 @@
+import {
+  Account,
+  AlkanesBalance,
+  AlkanesInfo,
+  BabylonTxInfo,
+  CAT20Balance,
+  CAT20TokenInfo,
+  CAT721CollectionInfo,
+  CAT_VERSION,
+  Inscription,
+  RuneBalance,
+  RuneInfo,
+  TokenBalance,
+  TokenInfo,
+  ToSignData,
+  WalletKeyring,
+} from '@unisat/wallet-shared'
+import { ChainType } from '@unisat/wallet-types'
+import React, { useContext } from 'react'
+
+export type RouteParamList = {
+  WelcomeScreen: undefined
+  UnlockScreen: {
+    autoUnlockByFace: boolean
+  }
+  CreatePasswordScreen: {
+    isNewAccount?: boolean
+    isKeystone?: boolean
+    fromColdWallet?: boolean
+  }
+
+  MainScreen: undefined
+
+  // tabs
+  WalletTabScreen: undefined
+  AppTabScreen: undefined
+  TabMainScreen: undefined
+  DiscoverTabScreen: undefined
+  SettingsTabScreen: undefined
+
+  // WALLET
+  CreateHDWalletScreen: {
+    restoreTiTle?: boolean
+    topTitle?: boolean
+    finalButton?: string
+    existingMnemonic?: string
+    isBackupFlow?: boolean
+
+    isImport?: boolean
+    comeFrom?: string
+    fromUnlock?: boolean
+    goBack?: boolean
+  }
+  CreateSimpleWalletScreen: undefined
+  CreateWatchWalletScreen: undefined
+  CreateColdWalletScreen: {
+    fromUnlock?: boolean
+  }
+  CreateKeystoneWalletScreen: {
+    fromUnlock?: boolean
+  }
+
+  EditWalletNameScreen: {
+    keyring: WalletKeyring
+  }
+  ExportMnemonicsScreen: { keyring: WalletKeyring }
+  ExportPrivateKeyScreen: {
+    account: Account
+  }
+  SwitchAccountScreen: undefined
+  ReceiveScreen: undefined
+  HistoryScreen: undefined
+  KeyringOrAccountScreen: undefined
+  AddKeyringScreen: undefined
+  ImportHDWalletScreen: {
+    comeFrom?: string
+  }
+  CreateAccountScreen: {
+    keyringKey?: string
+  }
+  CreateKeystoneScreen: {
+    comeFrom?: string
+    goBack?: boolean
+  }
+  EditAccountNameScreen: {
+    account: Account
+  }
+  KeyringDetailScreen: {
+    keyringKey?: string
+  }
+
+  // Settings
+  ConnectedSitesScreen: undefined
+  AddressTypeScreen: undefined
+  AdvancedScreen: undefined
+  ContactsScreen: {
+    returnWithNetwork?: ChainType
+    lastEditedContactAddress?: string
+  }
+  EditContactScreen: {
+    address?: string
+    chain?: string
+    selectedNetworkFilter: string
+  }
+  AboutUsScreen: undefined
+  LanguageScreen: undefined
+  ChangePasswordScreen: undefined
+  ModuleAssets: undefined
+  NotificationListScreen: undefined
+
+  // Tools
+  UtxoToolsMainScreen: undefined
+  ScanScreen: {
+    from?: string
+  }
+  BrowserScreen: {
+    info: any
+  }
+
+  // BTC
+  TxCreateScreen: undefined
+
+  // INSCRIPTIONS
+  OrdinalsInscriptionScreen: {
+    inscription: Inscription
+    inscriptionId?: string
+    withSend?: boolean
+  }
+  SendOrdinalsInscriptionScreen: {
+    inscription: Inscription
+    inscriptionId?: string
+  }
+  SplitOrdinalsInscriptionScreen: {
+    inscription: Inscription
+    inscriptionId?: string
+  }
+
+  // BRC20
+  BRC20TokenScreen: {
+    ticker: string
+    tokenBalance?: TokenBalance
+  }
+  BRC20SendScreen: {
+    tokenBalance: TokenBalance
+    tokenInfo: TokenInfo
+    selectedInscriptionIds?: string[]
+    selectedAmount?: string
+  }
+  BRC20InscribeTransfer: {
+    ticker: string
+  }
+  BRC20SingleStepScreen: {
+    tokenBalance: TokenBalance
+    tokenInfo: TokenInfo
+  }
+  InscribeTransferScreen: {
+    ticker: string
+  }
+
+  // RUNES
+  RunesTokenScreen: {
+    runeid: string
+  }
+  SendRunesScreen: {
+    runeBalance: RuneBalance
+    runeInfo: RuneInfo
+  }
+
+  // Alkanes
+  AlkanesTokenScreen: {
+    alkaneid: string
+  }
+  SendAlkanesScreen: {
+    tokenBalance: AlkanesBalance
+    tokenInfo: AlkanesInfo
+  }
+  AlkanesCollectionScreen: {
+    collectionId: string
+  }
+  AlkanesNFTScreen: {
+    alkanesInfo: AlkanesInfo
+  }
+  SendAlkanesNFTScreen: {
+    alkanesInfo: AlkanesInfo
+  }
+
+  // CAT
+  CAT20TokenScreen: {
+    tokenId: string
+    version: CAT_VERSION
+  }
+  SendCAT20Screen: {
+    version: CAT_VERSION
+    cat20Balance: CAT20Balance
+    cat20Info: CAT20TokenInfo
+  }
+  MergeCAT20Screen: {
+    version: CAT_VERSION
+    cat20Balance: CAT20Balance
+    cat20Info: CAT20TokenInfo
+  }
+  CAT721CollectionScreen: {
+    collectionId: string
+    version: CAT_VERSION
+  }
+  CAT721NFTScreen: {
+    version: CAT_VERSION
+    collectionInfo: CAT721CollectionInfo
+    localId: string
+  }
+  SendCAT721Screen: {
+    version: CAT_VERSION
+    collectionInfo: CAT721CollectionInfo
+    localId: string
+  }
+
+  // Babylon
+  BabylonTxConfirmScreen: {
+    txInfo: BabylonTxInfo
+  }
+  BabylonStakingScreen: undefined
+  SendBabyScreen: undefined
+
+  // TX
+  TxConfirmScreen: {
+    toSignData: ToSignData
+  }
+  TxSuccessScreen: {
+    txid: string
+  }
+  TxFailScreen: {
+    error: string
+  }
+}
+
+export type RouteTypes = keyof RouteParamList
+
+type NavigateArgs<T extends RouteTypes> = RouteParamList[T] extends undefined
+  ? [screenName: T]
+  : [screenName: T, params: RouteParamList[T]]
+
+export interface NavigationContextType {
+  navigate<T extends RouteTypes>(...args: NavigateArgs<T>): void
+
+  replace<T extends RouteTypes>(...args: NavigateArgs<T>): void
+
+  poptotop: () => void
+  goBack: () => void
+  navToTab: () => void
+  navToTest: () => void
+  navToLock: (params?: any) => void
+  navToWelcome: () => void
+
+  getRouteState<T extends RouteTypes>(): RouteParamList[T]
+
+  navToUtxoTools: () => void
+  navToUrl: (url: string, externalBrowser?: boolean) => void
+
+  navToExplorerTx: (txid: string) => void
+  navToExplorerAddress: (address: string) => void
+
+  navToMarketPlace: () => void
+  navToMarketPlaceBrc20: (ticker: string) => void
+  navToInscribeBrc20: (ticker: string) => void
+
+  openExtensionInTab?: () => void // in extension only
+  navToRootHome: () => void // in extension only
+}
+
+const initContext = {
+  navigate: () => {},
+  poptotop: () => {},
+  goBack: () => {},
+  replace: () => {},
+  navToTab: () => {},
+  navToTest: () => {},
+  navToLock: () => {},
+  navToWelcome: () => {},
+
+  getRouteState<T>(): T {
+    // todo
+    return undefined as T
+  },
+
+  navToUtxoTools: () => {},
+
+  navToUrl: (url: string, externalBrowser?: boolean) => {},
+  navToExplorerTx: (txid: string) => {},
+  navToExplorerAddress: (address: string) => {},
+
+  navToMarketPlace: () => {},
+  navToMarketPlaceBrc20: (ticker: string) => {},
+  navToInscribeBrc20: (ticker: string) => {},
+
+  // in extension only
+  openExtensionInTab: () => {},
+  navToRootHome: () => {},
+}
+
+export const NavigationContext = React.createContext<NavigationContextType>(initContext)
+
+export function useNavigation() {
+  const ctx = useContext(NavigationContext)
+  return ctx
+}

package/src/context/PriceContext.tsx

@@ -1,4 +1,4 @@
-import { createContext, ReactNode, useCallback, useContext, useEffect, useState } from 'react'
+import React, { ReactNode, useCallback, useContext, useEffect, useState } from 'react'
 
 import { CoinPrice } from '@unisat/wallet-shared'
 import { useWallet } from './WalletContext'
@@ -11,7 +11,7 @@ interface PriceContextType {
   refreshCoinPrice: () => void
 }
 
-const PriceContext = createContext<PriceContextType>({} as PriceContextType)
+const PriceContext = React.createContext<PriceContextType>({} as PriceContextType)
 
 export function usePrice() {
   const context = useContext(PriceContext)