@bifold/core 2.4.5 → 2.5.0

package/src/services/keychain.ts

@@ -1,184 +0,0 @@
-import { Platform } from 'react-native'
-import Keychain, { getSupportedBiometryType } from 'react-native-keychain'
-import uuid from 'react-native-uuid'
-
-import { walletId, KeychainServices } from '../constants'
-import { WalletSecret } from '../types/security'
-import { LoginAttempt } from '../types/state'
-import { hashPIN } from '../utils/crypto'
-
-const keyFauxUserName = 'WalletFauxPINUserName'
-const saltFauxUserName = 'WalletFauxSaltUserName'
-const loginAttemptFauxUserName = 'WalletFauxLoginAttemptUserName'
-// TODO: consider combing WalletSalt, WalletKey all into Wallet Secret, then using partials when required
-export interface WalletSalt {
-  id: string
-  salt: string
-}
-
-export interface WalletKey {
-  key: string
-}
-
-export const optionsForKeychainAccess = (service: KeychainServices, useBiometrics = false): Keychain.Options => {
-  const opts: Keychain.Options = {
-    accessible: useBiometrics ? Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY : Keychain.ACCESSIBLE.ALWAYS,
-    service,
-  }
-
-  if (useBiometrics) {
-    opts.accessControl = Keychain.ACCESS_CONTROL.BIOMETRY_ANY
-  }
-
-  if (Platform.OS === 'android') {
-    opts.securityLevel = Keychain.SECURITY_LEVEL.ANY
-    if (!useBiometrics) {
-      opts.storage = Keychain.STORAGE_TYPE.AES
-    } else {
-      opts.storage = Keychain.STORAGE_TYPE.RSA
-    }
-  }
-
-  return opts
-}
-
-export const secretForPIN = async (PIN: string, salt?: string): Promise<WalletSecret> => {
-  const mySalt = salt ?? uuid.v4().toString()
-  const myKey = await hashPIN(PIN, mySalt)
-  const secret: WalletSecret = {
-    id: walletId,
-    key: myKey,
-    salt: mySalt,
-  }
-
-  return secret
-}
-
-export const wipeWalletKey = async (useBiometrics: boolean) => {
-  const opts = optionsForKeychainAccess(KeychainServices.Key, useBiometrics)
-  await Keychain.resetGenericPassword(opts)
-}
-
-export const storeWalletKey = async (secret: WalletKey, useBiometrics = false): Promise<boolean> => {
-  const opts = optionsForKeychainAccess(KeychainServices.Key, useBiometrics)
-  const secretAsString = JSON.stringify(secret)
-  await wipeWalletKey(useBiometrics)
-  const result = await Keychain.setGenericPassword(keyFauxUserName, secretAsString, opts)
-  return Boolean(result)
-}
-
-export const storeWalletSalt = async (secret: WalletSalt): Promise<boolean> => {
-  const opts = optionsForKeychainAccess(KeychainServices.Salt, false)
-  const secretAsString = JSON.stringify(secret)
-  const result = await Keychain.setGenericPassword(saltFauxUserName, secretAsString, opts)
-  return Boolean(result)
-}
-
-export const storeLoginAttempt = async (loginAttempt: LoginAttempt): Promise<boolean> => {
-  const opts = optionsForKeychainAccess(KeychainServices.LoginAttempt, false)
-  const loginAttemptAsString = JSON.stringify(loginAttempt)
-  const result = await Keychain.setGenericPassword(loginAttemptFauxUserName, loginAttemptAsString, opts)
-  return Boolean(result)
-}
-
-export const storeWalletSecret = async (secret: WalletSecret, useBiometrics = false): Promise<boolean> => {
-  let keyResult = false
-  if (secret.key) {
-    keyResult = await storeWalletKey({ key: secret.key }, useBiometrics)
-  }
-
-  const saltResult = await storeWalletSalt({ id: secret.id, salt: secret.salt })
-
-  return keyResult && saltResult
-}
-
-export const loadWalletSalt = async (): Promise<WalletSalt | undefined> => {
-  let salt: WalletSalt | undefined = undefined
-  const opts: Keychain.Options = {
-    service: KeychainServices.Salt,
-  }
-  const result = await Keychain.getGenericPassword(opts)
-  if (!result) {
-    return
-  }
-
-  // salt data is stored and returned as a string and needs to be parsed
-  const parsedSalt = JSON.parse(result.password)
-  if (!parsedSalt.id || !parsedSalt.salt) {
-    throw new Error('Wallet salt failed to load')
-  }
-
-  salt = {
-    id: parsedSalt.id,
-    salt: parsedSalt.salt,
-  }
-
-  return salt
-}
-
-export const loadLoginAttempt = async (): Promise<LoginAttempt | undefined> => {
-  const opts: Keychain.Options = {
-    service: KeychainServices.LoginAttempt,
-  }
-
-  const result = await Keychain.getGenericPassword(opts)
-  if (!result) {
-    return
-  }
-
-  return JSON.parse(result.password) as LoginAttempt
-}
-
-export const loadWalletKey = async (title?: string, description?: string): Promise<WalletKey | undefined> => {
-  let opts: Keychain.Options = {
-    service: KeychainServices.Key,
-  }
-
-  if (title && description) {
-    opts = {
-      ...opts,
-      authenticationPrompt: {
-        title,
-        description,
-      },
-    }
-  }
-  const result = await Keychain.getGenericPassword(opts)
-
-  if (!result) {
-    return
-  }
-
-  return JSON.parse(result.password) as WalletKey
-}
-
-export const loadWalletSecret = async (title?: string, description?: string): Promise<WalletSecret | undefined> => {
-  let salt: WalletSalt | undefined
-  let key: WalletKey | undefined
-  let secret: WalletSecret | undefined = undefined
-  try {
-    salt = await loadWalletSalt()
-    key = await loadWalletKey(title, description)
-  } catch (e: any) {
-    throw new Error(e?.message ?? e)
-  }
-
-  if (!salt?.id || !salt?.salt || !key) {
-    throw new Error('Wallet secret is missing key property')
-  }
-
-  secret = {
-    id: salt.id,
-    key: key.key,
-    salt: salt.salt,
-  }
-  return secret
-}
-
-// This function checks if the biometrics on a device have been configured
-// If fingerprints or a face scan is setup, this will return true
-// If the device supports biometrics but they have not been configured, it will return false
-export const isBiometricsActive = async (): Promise<boolean> => {
-  const result = await getSupportedBiometryType()
-  return Boolean(result)
-}

package/src/services/logger.ts

@@ -1,89 +0,0 @@
-import { BaseLogger } from '@credo-ts/core'
-import { consoleTransport, logger } from 'react-native-logs'
-
-import { BifoldError } from '../types/error'
-
-export class BifoldLogger extends BaseLogger {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  protected _log: any
-  protected _config = {
-    levels: {
-      test: 0,
-      trace: 0,
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3,
-      fatal: 4,
-    },
-    severity: 'debug',
-    async: true,
-    dateFormat: 'time',
-    printDate: false,
-  }
-
-  public constructor() {
-    super()
-
-    const transport = [consoleTransport]
-    const config = {
-      ...this._config,
-      transport,
-    }
-
-    this._log = logger.createLogger<'test' | 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal'>(config)
-  }
-
-  protected messageFormatter(...msgs: unknown[]): unknown[] {
-    return msgs.map((msg) => {
-      if (msg instanceof Error) {
-        return JSON.stringify(
-          {
-            name: msg.name,
-            message: msg.message,
-            stack:
-              msg.stack
-                ?.split('\n')
-                .slice(1)
-                .map((line) => line.trim()) ?? [],
-          },
-          null,
-          2
-        )
-      }
-      return typeof msg === 'object' ? JSON.stringify(msg, null, 2) : msg
-    })
-  }
-
-  public test(...msgs: unknown[]): void {
-    this._log?.test(...this.messageFormatter(...msgs))
-  }
-
-  public trace(...msgs: unknown[]): void {
-    this._log?.trace(...this.messageFormatter(...msgs))
-  }
-
-  public debug(...msgs: unknown[]): void {
-    this._log?.debug(...this.messageFormatter(...msgs))
-  }
-
-  public info(...msgs: unknown[]): void {
-    this._log?.info(...this.messageFormatter(...msgs))
-  }
-
-  public warn(...msgs: unknown[]): void {
-    this._log?.warn(...this.messageFormatter(...msgs))
-  }
-
-  public error(...msgs: unknown[]): void {
-    this._log?.error(...this.messageFormatter(...msgs))
-  }
-
-  public fatal(...msgs: unknown[]): void {
-    this._log?.fatal(...this.messageFormatter(...msgs))
-  }
-
-  public report(bifoldError: BifoldError): void {
-    this._log?.info({ message: 'No remote logging configured, report not sent for error:', data: bifoldError.message })
-  }
-}

package/src/services/storage.ts

@@ -1,136 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage'
-import { BifoldLogger } from './logger'
-
-export class PersistentStorage<T> {
-  private _state?: T
-  private log?: BifoldLogger
-
-  constructor(logger: any) {
-    // this._state = state
-    this.log = logger
-  }
-
-  public static fetchValueForKey = async <T>(key: string, log?: BifoldLogger): Promise<T | undefined> => {
-    try {
-      const value = await AsyncStorage.getItem(key)
-      if (!value) {
-        return
-      }
-
-      return JSON.parse(value)
-    } catch (error) {
-      log?.error(`Error loading state for key ${key}, ${error as Error}`)
-    }
-  }
-
-  public static storeValueForKey = async <T>(key: string, value: T, log?: BifoldLogger): Promise<void> => {
-    try {
-      const serializedState = JSON.stringify(value)
-      return AsyncStorage.setItem(key, serializedState)
-    } catch (error) {
-      log?.error(`Error loading state for key ${key}, ${error as Error}`)
-
-      throw error
-    }
-  }
-
-  public static removeValueForKey = async (key: string, log?: BifoldLogger): Promise<void> => {
-    try {
-      return AsyncStorage.removeItem(key)
-    } catch (error) {
-      log?.error(`Error removing state for key ${key}, ${error as Error}`)
-
-      throw error
-    }
-  }
-
-  public async setValueForKey(key: string, value: Partial<T>) {
-    if (!this._state) {
-      throw new Error("State hasn't been initialized")
-    }
-
-    // @ts-expect-error Fix complicated type error
-    this._state[key] = value
-
-    try {
-      const serializedState = JSON.stringify(value)
-      await AsyncStorage.setItem(key, serializedState)
-    } catch (error) {
-      this.log?.error(`Error saving state for key ${key}, ${error as Error}`)
-    }
-  }
-
-  public async getValueForKey(key: string): Promise<Partial<T> | undefined> {
-    try {
-      if (!this._state) {
-        await this.load()
-      }
-
-      // @ts-expect-error Fix complicated type error.
-      return this._state[key] as Partial<T>
-    } catch (error) {
-      this.log?.error(`Error loading state for key ${key}, ${error as Error}`)
-    }
-  }
-
-  public async migrateStorageKey(oldKey: string, newKey: string): Promise<boolean> {
-    try {
-      const value = await AsyncStorage.getItem(oldKey)
-      if (!value) {
-        return false
-      }
-
-      await AsyncStorage.setItem(newKey, value)
-      await AsyncStorage.removeItem(oldKey)
-
-      // @ts-expect-error Fix complicated type error
-      delete this._state[oldKey]
-      // @ts-expect-error Fix complicated type error
-      this._state[newKey] = JSON.parse(value)
-
-      return true
-    } catch (error) {
-      this.log?.error(`Error migrating state for key ${oldKey}, ${error as Error}`)
-    }
-
-    return false
-  }
-
-  public async flush() {
-    if (!this._state) {
-      return
-    }
-
-    try {
-      const keys = Object.keys(this._state)
-      for (const key of keys) {
-        // @ts-expect-error Fix complicated type error
-        const value = this._state[key]
-        const serializedState = JSON.stringify(value)
-        await AsyncStorage.setItem(key, serializedState)
-      }
-    } catch (error) {
-      this.log?.error('Error saving state', error as Error)
-    }
-  }
-
-  public async load() {
-    try {
-      const keys = await AsyncStorage.getAllKeys()
-      const items = await AsyncStorage.multiGet(keys)
-
-      items.forEach(([key, value]) => {
-        if (value === null || value === undefined) {
-          return
-        }
-
-        const parsedValue = JSON.parse(value)
-
-        // @ts-expect-error Fix complicated type error
-        this._state = { ...this._state, [key]: parsedValue }
-      })
-    } catch (error) {
-      this.log?.error('Error loading state', error as Error)
-    }
-  }
-}

package/src/theme-builder.ts

@@ -1,157 +0,0 @@
-import {
-  IColorPalette,
-  ITheme,
-  createButtonsTheme,
-  createChatTheme,
-  createHomeTheme,
-  createInputInlineMessageTheme,
-  createInputsTheme,
-  createListItemsTheme,
-  createNavigationTheme,
-  createSettingsTheme,
-  createTabTheme,
-  createTextTheme,
-  createOnboardingTheme,
-  createDialogTheme,
-  createLoadingTheme,
-  createPINInputTheme,
-} from './theme'
-import lodash from 'lodash'
-
-/**
- * DeepPartial is a utility type that recursively makes all properties of a type optional.
- */
-export type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T
-
-/**
- * ThemeBuilder is a utility class to extend an existing theme with additional properties.
- *
- * @class ThemeBuilder
- */
-export class ThemeBuilder {
-  private _theme: ITheme
-  private _themeOverrides: DeepPartial<ITheme>
-
-  /**
-   * Creates an instance of ThemeBuilder.
-   *
-   * @param {ITheme} baseTheme - The initial theme object to extend.
-   */
-  constructor(baseTheme: ITheme) {
-    this._theme = baseTheme
-    this._themeOverrides = {}
-  }
-
-  /**
-   * Extension of the lodash.merge function that merges two objects deeply,
-   * while preserving explicit undefined values in the source object.
-   *
-   * @param {T} target - The target object to merge into.
-   * @param {DeepPartial<T>} source - The source object to merge from.
-   * @returns {*} {T} Returns the merged object.
-   */
-  private _merge<T extends object>(target: T, source: DeepPartial<T>): T {
-    // note: without the empty object, lodash.merge will mutate the original theme overrides,
-    // and not properly update the nested properties
-    return lodash.mergeWith({}, target, source, (objValue, srcValue, key, obj) => {
-      // If source explicitly sets the value to undefined, keep it as undefined
-      if (objValue !== srcValue && typeof srcValue === 'undefined') {
-        obj[key] = undefined
-      }
-    })
-  }
-
-  /**
-   * Sets the color pallet for the theme.
-   *
-   * Note: This method is mostly a convenience method to set the color pallet for the theme.
-   * The same can be achieved by directly modifying the theme object using the `withOverrides` method.
-   *
-   * @param {IColorPalette} colorPalette - The color pallet to set for the theme.
-   * @returns {*} {ThemeBuilder} Returns the instance of ThemeBuilder for method chaining.
-   */
-  setColorPalette(colorPalette: IColorPalette): this {
-    this.withOverrides({
-      ColorPalette: colorPalette,
-    })
-
-    return this
-  }
-
-  /**
-   * Overrides properties in the current theme with the provided themeOverrides.
-   *
-   * Note: This will overwrite existing properties in the current theme with those from the provided themeOverrides.
-   *
-   * @example
-   * new ThemeBuilder({ Buttons: { color: 'purple', size: 'large' }})
-   * .withOverrides({ Buttons: { color: 'red' }})
-   * .withOverrides({ Buttons: { spacing: 10 }}) // => { Buttons: { color: 'red', size: 'large', spacing: 10 }}
-   *
-   * @example
-   * new ThemeBuilder({ Buttons: { critical: { padding: 10, margin: 0 }}})
-   * .withOverrides((theme) => ({
-   *  Buttons: { critical: { padding: 0, margin: -1 } },
-   * })) // => { Buttons: { critical: { padding: 0, margin: -1 } }}
-   *
-   * @param {DeepPartial<ITheme> | ((theme: ITheme) => DeepPartial<ITheme>) } themeOverrides A partial theme object to merge with the current theme or a callback function that receives the current theme and returns a partial theme object.
-   * @returns {*} {ThemeBuilder} Returns the instance of ThemeBuilder for method chaining.
-   */
-  withOverrides(themeOverrides: DeepPartial<ITheme> | ((theme: ITheme) => DeepPartial<ITheme>)): this {
-    const resolvedOverrides = typeof themeOverrides === 'function' ? themeOverrides(this._theme) : themeOverrides
-
-    this._themeOverrides = this._merge(this._themeOverrides, resolvedOverrides)
-
-    // Rebuild the theme with the new overrides so following chained calls will use the updated theme.
-    this._theme = this.build()
-
-    // Return the instance for method chaining
-    return this
-  }
-
-  /**
-   * Builds and returns the final theme object.
-   *
-   * @returns {*} {ITheme} Returns the final theme object.
-   */
-  build(): ITheme {
-    // Step 1. Merge the theme overrides onto the original theme, producing the new base theme.
-    const baseTheme = this._merge(this._theme, this._themeOverrides)
-
-    if (lodash.isEqual(baseTheme, this._theme)) {
-      // If the base theme is equal to the current theme, return the current theme
-      // This avoids unnecessary recomputation of dependent themes
-      return this._theme
-    }
-
-    // Step 2. Generate computed properties that depend on the base theme
-    const dependentThemes: Partial<ITheme> = {
-      TextTheme: createTextTheme(baseTheme),
-      InputInlineMessage: createInputInlineMessageTheme(baseTheme),
-      Inputs: createInputsTheme(baseTheme),
-      Buttons: createButtonsTheme(baseTheme),
-      ListItems: createListItemsTheme(baseTheme),
-      TabTheme: createTabTheme(baseTheme),
-      NavigationTheme: createNavigationTheme(baseTheme),
-      HomeTheme: createHomeTheme(baseTheme),
-      SettingsTheme: createSettingsTheme(baseTheme),
-      ChatTheme: createChatTheme(baseTheme),
-      OnboardingTheme: createOnboardingTheme(baseTheme),
-      DialogTheme: createDialogTheme(baseTheme),
-      LoadingTheme: createLoadingTheme(baseTheme),
-      PINInputTheme: createPINInputTheme(baseTheme),
-    }
-
-    /**
-     * Step 3. Merge all together - base + generated + overrides
-     *
-     * Why do we apply the overrides after the dependent themes?
-     * Because the `dependentThemes` contain additional properties that may have
-     * been modified by the overrides previously.
-     */
-    const newBaseTheme = this._merge(baseTheme, dependentThemes)
-    this._theme = this._merge(newBaseTheme, this._themeOverrides)
-
-    return this._theme
-  }
-}