@sbaiahmed1/react-native-biometrics/lib/commonjs/index.js

React Native biometric authentication library for iOS and Android. Easy integration of Face ID, Touch ID, and Fingerprint authentication with TypeScript support. Compatible with new architecture (TurboModules) and Expo. Secure mobile login solution.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
Object.defineProperty(exports, "BiometricStrength", {
  enumerable: true,
  get: function () {
    return _types.BiometricStrength;
  }
});
Object.defineProperty(exports, "LogLevel", {
  enumerable: true,
  get: function () {
    return _logger.LogLevel;
  }
});
exports.authenticateWithOptions = authenticateWithOptions;
exports.clearLogs = clearLogs;
exports.configure = configure;
exports.configureKeyAlias = configureKeyAlias;
Object.defineProperty(exports, "configureLogger", {
  enumerable: true,
  get: function () {
    return _logger.configureLogger;
  }
});
exports.createKeys = createKeys;
exports.deleteKeys = deleteKeys;
Object.defineProperty(exports, "enableLogging", {
  enumerable: true,
  get: function () {
    return _logger.enableLogging;
  }
});
exports.getAllKeys = getAllKeys;
exports.getDefaultKeyAlias = getDefaultKeyAlias;
exports.getDeviceIntegrityStatus = getDeviceIntegrityStatus;
exports.getDiagnosticInfo = getDiagnosticInfo;
exports.getKeyAttributes = getKeyAttributes;
exports.getLogs = getLogs;
exports.isSensorAvailable = isSensorAvailable;
Object.defineProperty(exports, "logger", {
  enumerable: true,
  get: function () {
    return _logger.logger;
  }
});
exports.runBiometricTest = runBiometricTest;
exports.setDebugMode = setDebugMode;
Object.defineProperty(exports, "setLogLevel", {
  enumerable: true,
  get: function () {
    return _logger.setLogLevel;
  }
});
exports.simplePrompt = simplePrompt;
exports.startBiometricChangeDetection = startBiometricChangeDetection;
exports.stopBiometricChangeDetection = stopBiometricChangeDetection;
exports.subscribeToBiometricChanges = subscribeToBiometricChanges;
exports.unsubscribeFromBiometricChanges = unsubscribeFromBiometricChanges;
exports.validateKeyIntegrity = validateKeyIntegrity;
exports.validateSignature = validateSignature;
exports.verifyKeySignature = verifyKeySignature;
var _NativeReactNativeBiometrics = _interopRequireDefault(require("./NativeReactNativeBiometrics.js"));
var _logger = require("./logger.js");
var _reactNative = require("react-native");
var _types = require("./types.js");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function isSensorAvailable(options) {
  _logger.logger.debug('Checking sensor availability', 'isSensorAvailable');
  if (_reactNative.Platform.OS === 'android') {
    const biometricStrength = options?.biometricStrength || _types.BiometricStrength.Strong;
    return _NativeReactNativeBiometrics.default.isSensorAvailable(biometricStrength).then(result => {
      _logger.logger.info('Sensor availability check completed', 'isSensorAvailable', {
        available: result.available,
        biometryType: result.biometryType
      });
      return result;
    }).catch(error => {
      _logger.logger.error('Sensor availability check failed', 'isSensorAvailable', error);
      throw error;
    });
  }

  // For iOS, we still call without parameters as iOS doesn't support biometric strength
  return _NativeReactNativeBiometrics.default.isSensorAvailable().then(result => {
    _logger.logger.info('Sensor availability check completed', 'isSensorAvailable', {
      available: result.available,
      biometryType: result.biometryType
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Sensor availability check failed', 'isSensorAvailable', error);
    throw error;
  });
}
function simplePrompt(promptMessage, options) {
  _logger.logger.debug('Starting simple biometric prompt', 'simplePrompt', {
    promptMessage,
    biometricStrength: options?.biometricStrength
  });
  if (_reactNative.Platform.OS === 'android') {
    return _NativeReactNativeBiometrics.default.simplePrompt(promptMessage, options?.biometricStrength).then(result => {
      _logger.logger.info('Simple prompt completed', 'simplePrompt', {
        success: result
      });
      return result;
    }).catch(error => {
      _logger.logger.error('Simple prompt failed', 'simplePrompt', error, {
        promptMessage,
        biometricStrength: options?.biometricStrength
      });
      throw error;
    });
  }
  // iOS and other platforms ignore biometricStrength and use default behavior
  return _NativeReactNativeBiometrics.default.simplePrompt(promptMessage).then(result => {
    _logger.logger.info('Simple prompt completed', 'simplePrompt', {
      success: result
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Simple prompt failed', 'simplePrompt', error, {
      promptMessage
    });
    throw error;
  });
}
function authenticateWithOptions(options) {
  _logger.logger.debug('Starting authentication with options', 'authenticateWithOptions');
  if (_reactNative.Platform.OS === 'android' && options.biometricStrength) {
    return _NativeReactNativeBiometrics.default.authenticateWithOptions(options).then(result => {
      _logger.logger.info('Authentication with options completed', 'authenticateWithOptions', {
        success: result.success
      });
      return result;
    }).catch(error => {
      _logger.logger.error('Authentication with options failed', 'authenticateWithOptions', error);
      throw error;
    });
  }

  // For iOS or Android without biometricStrength, remove biometricStrength from options
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const {
    biometricStrength: _,
    ...cleanOptions
  } = options;
  return _NativeReactNativeBiometrics.default.authenticateWithOptions(cleanOptions).then(result => {
    _logger.logger.info('Authentication with options completed', 'authenticateWithOptions', {
      success: result.success
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Authentication with options failed', 'authenticateWithOptions', error);
    throw error;
  });
}
function createKeys(keyAlias, keyType, biometricStrength) {
  _logger.logger.debug('Creating biometric keys', 'createKeys', {
    keyAlias,
    keyType,
    biometricStrength
  });
  return _NativeReactNativeBiometrics.default.createKeys(keyAlias, keyType, biometricStrength).then(result => {
    _logger.logger.info('Keys created successfully', 'createKeys', {
      keyAlias,
      keyType,
      biometricStrength,
      publicKeyLength: result.publicKey?.length
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Key creation failed', 'createKeys', error, {
      keyAlias,
      keyType,
      biometricStrength
    });
    throw error;
  });
}
function deleteKeys(keyAlias) {
  _logger.logger.debug('Deleting biometric keys', 'deleteKeys', {
    keyAlias
  });
  return _NativeReactNativeBiometrics.default.deleteKeys(keyAlias).then(result => {
    _logger.logger.info('Keys deletion completed', 'deleteKeys', {
      keyAlias,
      success: result.success
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Key deletion failed', 'deleteKeys', error, {
      keyAlias
    });
    throw error;
  });
}
function validateKeyIntegrity(keyAlias) {
  _logger.logger.debug('Validating key integrity', 'validateKeyIntegrity', {
    keyAlias
  });
  return _NativeReactNativeBiometrics.default.validateKeyIntegrity(keyAlias).then(result => {
    _logger.logger.info('Key integrity validation completed', 'validateKeyIntegrity', {
      keyAlias,
      valid: result.valid,
      keyExists: result.keyExists,
      integrityChecks: result.integrityChecks
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Key integrity validation failed', 'validateKeyIntegrity', error, {
      keyAlias
    });
    throw error;
  });
}
function verifyKeySignature(keyAlias = '', data, promptTitle, promptSubtitle, cancelButtonText) {
  _logger.logger.debug('Verifying key signature', 'verifyKeySignature', {
    keyAlias,
    dataLength: data.length
  });
  return _NativeReactNativeBiometrics.default.verifyKeySignature(keyAlias, data, promptTitle, promptSubtitle, cancelButtonText).then(result => {
    _logger.logger.info('Key signature verification completed', 'verifyKeySignature', {
      keyAlias,
      success: result.success,
      hasSignature: !!result.signature
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Key signature verification failed', 'verifyKeySignature', error, {
      keyAlias
    });
    throw error;
  });
}
function validateSignature(keyAlias = '', data, signature) {
  _logger.logger.debug('Validating signature', 'validateSignature', {
    keyAlias,
    dataLength: data.length,
    signatureLength: signature.length
  });
  return _NativeReactNativeBiometrics.default.validateSignature(keyAlias, data, signature).then(result => {
    _logger.logger.info('Signature validation completed', 'validateSignature', {
      keyAlias,
      valid: result.valid
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Signature validation failed', 'validateSignature', error, {
      keyAlias
    });
    throw error;
  });
}
function getKeyAttributes(keyAlias) {
  _logger.logger.debug('Getting key attributes', 'getKeyAttributes', {
    keyAlias
  });
  return _NativeReactNativeBiometrics.default.getKeyAttributes(keyAlias).then(result => {
    _logger.logger.info('Key attributes retrieved', 'getKeyAttributes', {
      keyAlias,
      exists: result.exists,
      attributes: result.attributes
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Key attributes retrieval failed', 'getKeyAttributes', error, {
      keyAlias
    });
    throw error;
  });
}

// Key management configuration
function configureKeyAlias(keyAlias) {
  _logger.logger.debug('Configuring key alias', 'configureKeyAlias', {
    keyAlias
  });
  return _NativeReactNativeBiometrics.default.configureKeyAlias(keyAlias).then(result => {
    _logger.logger.info('Key alias configured successfully', 'configureKeyAlias', {
      keyAlias
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Key alias configuration failed', 'configureKeyAlias', error, {
      keyAlias
    });
    throw error;
  });
}
function getDefaultKeyAlias() {
  _logger.logger.debug('Getting default key alias', 'getDefaultKeyAlias');
  return _NativeReactNativeBiometrics.default.getDefaultKeyAlias().then(result => {
    _logger.logger.info('Default key alias retrieved', 'getDefaultKeyAlias', {
      keyAlias: result
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Failed to get default key alias', 'getDefaultKeyAlias', error);
    throw error;
  });
}
function getAllKeys(customAlias) {
  _logger.logger.debug('Getting all keys', 'getAllKeys', {
    customAlias
  });
  return _NativeReactNativeBiometrics.default.getAllKeys(customAlias).then(result => {
    _logger.logger.info('All keys retrieved', 'getAllKeys', {
      keyCount: result.keys?.length || 0,
      customAlias
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Failed to get all keys', 'getAllKeys', error);
    throw error;
  });
}

// Debugging utilities
function getDiagnosticInfo() {
  _logger.logger.debug('Getting diagnostic information', 'getDiagnosticInfo');
  return _NativeReactNativeBiometrics.default.getDiagnosticInfo().then(result => {
    _logger.logger.info('Diagnostic information retrieved', 'getDiagnosticInfo', {
      platform: result.platform,
      osVersion: result.osVersion,
      deviceModel: result.deviceModel,
      biometricCapabilities: result.biometricCapabilities
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Failed to get diagnostic information', 'getDiagnosticInfo', error);
    throw error;
  });
}
function runBiometricTest() {
  _logger.logger.debug('Running biometric test', 'runBiometricTest');
  return _NativeReactNativeBiometrics.default.runBiometricTest().then(result => {
    _logger.logger.info('Biometric test completed', 'runBiometricTest', {
      success: result.success,
      errorCount: result.errors?.length || 0,
      warningCount: result.warnings?.length || 0
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Biometric test failed', 'runBiometricTest', error);
    throw error;
  });
}
function setDebugMode(enabled) {
  _logger.logger.debug('Setting debug mode', 'setDebugMode', {
    enabled
  });

  // Enable/disable centralized logging based on debug mode
  _logger.logger.setEnabled(enabled);
  if (enabled) {
    _logger.logger.setLevel(_logger.LogLevel.DEBUG);
  } else {
    _logger.logger.setLevel(_logger.LogLevel.INFO);
  }
  return _NativeReactNativeBiometrics.default.setDebugMode(enabled).then(result => {
    _logger.logger.info('Debug mode updated', 'setDebugMode', {
      enabled
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Failed to set debug mode', 'setDebugMode', error, {
      enabled
    });
    throw error;
  });
}
function getDeviceIntegrityStatus() {
  _logger.logger.debug('Getting device integrity status', 'getDeviceIntegrityStatus');
  return _NativeReactNativeBiometrics.default.getDeviceIntegrityStatus().then(result => {
    _logger.logger.info('Device integrity status retrieved', 'getDeviceIntegrityStatus', {
      isCompromised: result.isCompromised,
      riskLevel: result.riskLevel
    });
    return result;
  }).catch(error => {
    _logger.logger.error('Failed to get device integrity status', 'getDeviceIntegrityStatus', error);
    throw error;
  });
}

// Configuration types

// Initialize library with configuration
function configure(config) {
  _logger.logger.debug('Configuring library', 'configure', config);
  if (config.keyAlias) {
    return configureKeyAlias(config.keyAlias).then(result => {
      _logger.logger.info('Library configuration completed', 'configure', config);
      return result;
    }).catch(error => {
      _logger.logger.error('Library configuration failed', 'configure', error, config);
      throw error;
    });
  }
  _logger.logger.info('Library configuration completed (no key alias)', 'configure', config);
  return Promise.resolve();
}

// Export types for TypeScript users

// Export logging utilities

// Convenience function to get logs for debugging
function getLogs() {
  return _logger.logger.getLogs();
}

// Convenience function to clear logs
function clearLogs() {
  _logger.logger.clearLogs();
}

// Biometric Change Detection API

/**
 * Subscribes to biometric change events.
 *
 * @param callback - Function to be called when biometric changes are detected
 * @returns EventSubscription that can be used to unsubscribe
 */
function subscribeToBiometricChanges(callback) {
  _logger.logger.debug('Subscribing to biometric changes', 'subscribeToBiometricChanges');

  // Subscribe using DeviceEventEmitter for cross-architecture compatibility
  // The native modules emit events via DeviceEventManagerModule
  return _reactNative.DeviceEventEmitter.addListener('onBiometricChange', callback);
}

/**
 * Unsubscribes from biometric change events.
 *
 * @param subscription - The EventSubscription returned from subscribeToBiometricChanges
 */
function unsubscribeFromBiometricChanges(subscription) {
  _logger.logger.debug('Unsubscribing from biometric changes', 'unsubscribeFromBiometricChanges');
  subscription.remove();
}

/**
 * Starts biometric change detection.
 * This will begin monitoring for changes in biometric enrollment.
 *
 * @returns Promise that resolves when detection is started
 */
function startBiometricChangeDetection() {
  _logger.logger.debug('Starting biometric change detection', 'startBiometricChangeDetection');
  return _NativeReactNativeBiometrics.default.startBiometricChangeDetection();
}

/**
 * Stops biometric change detection.
 * This will stop monitoring for changes in biometric enrollment.
 *
 * @returns Promise that resolves when detection is stopped
 */
function stopBiometricChangeDetection() {
  _logger.logger.debug('Stopping biometric change detection', 'stopBiometricChangeDetection');
  return _NativeReactNativeBiometrics.default.stopBiometricChangeDetection();
}
//# sourceMappingURL=index.js.map