react-native-ble-mesh 1.0.1

package/examples/testing/test-helper.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+/**
+ * Testing Helper Example
+ *
+ * Shows how to use the library in unit tests with MockTransport.
+ * Compatible with Jest, Mocha, and other test frameworks.
+ *
+ * Usage in tests:
+ *   const { createTestPair, createTestMesh } = require('react-native-ble-mesh/examples/testing/test-helper');
+ */
+
+'use strict';
+
+const { MeshService, MockTransport, MemoryStorage, utils } = require('../../src');
+
+/**
+ * Create a single test mesh instance
+ * @param {Object} options - Configuration options
+ * @param {string} [options.displayName='TestNode'] - Display name
+ * @returns {Promise<{mesh: MeshService, transport: MockTransport}>}
+ */
+async function createTestMesh(options = {}) {
+  const mesh = new MeshService({
+    displayName: options.displayName || 'TestNode'
+  });
+
+  const transport = new MockTransport({ localPeerId: utils.generateUUID() });
+
+  await mesh.initialize({
+    storage: new MemoryStorage()
+  });
+
+  await mesh.start(transport);
+
+  return { mesh, transport };
+}
+
+/**
+ * Create a pair of connected test mesh instances
+ * @param {Object} options - Configuration options
+ * @param {string} [options.name1='Alice'] - First node name
+ * @param {string} [options.name2='Bob'] - Second node name
+ * @returns {Promise<{alice: MeshService, bob: MeshService, aliceTransport: MockTransport, bobTransport: MockTransport}>}
+ */
+async function createTestPair(options = {}) {
+  const { mesh: alice, transport: aliceTransport } = await createTestMesh({
+    displayName: options.name1 || 'Alice'
+  });
+
+  const { mesh: bob, transport: bobTransport } = await createTestMesh({
+    displayName: options.name2 || 'Bob'
+  });
+
+  // Link the transports
+  aliceTransport.linkTo(bobTransport);
+
+  return { alice, bob, aliceTransport, bobTransport };
+}
+
+/**
+ * Create a mesh network of test nodes
+ * @param {number} count - Number of nodes to create
+ * @param {string} [topology='chain'] - 'chain', 'star', or 'full'
+ * @returns {Promise<Array<{mesh: MeshService, transport: MockTransport}>>}
+ */
+async function createTestNetwork(count, topology = 'chain') {
+  const nodes = [];
+
+  // Create nodes
+  for (let i = 0; i < count; i++) {
+    const node = await createTestMesh({
+      displayName: `Node${i + 1}`
+    });
+    nodes.push(node);
+  }
+
+  // Connect based on topology
+  switch (topology) {
+    case 'chain':
+      // A - B - C - D
+      for (let i = 0; i < nodes.length - 1; i++) {
+        nodes[i].transport.linkTo(nodes[i + 1].transport);
+      }
+      break;
+
+    case 'star':
+      // All connect to first node
+      for (let i = 1; i < nodes.length; i++) {
+        nodes[0].transport.linkTo(nodes[i].transport);
+      }
+      break;
+
+    case 'full':
+      // Everyone connects to everyone
+      for (let i = 0; i < nodes.length; i++) {
+        for (let j = i + 1; j < nodes.length; j++) {
+          nodes[i].transport.linkTo(nodes[j].transport);
+        }
+      }
+      break;
+
+    default:
+      throw new Error(`Unknown topology: ${topology}`);
+  }
+
+  return nodes;
+}
+
+/**
+ * Clean up test mesh instances
+ * @param {...MeshService} meshes - Mesh instances to clean up
+ */
+async function cleanupTestMeshes(...meshes) {
+  for (const mesh of meshes) {
+    try {
+      await mesh.stop();
+      await mesh.destroy();
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+/**
+ * Wait for a specific event with timeout
+ * @param {MeshService} mesh - Mesh service instance
+ * @param {string} eventName - Event to wait for
+ * @param {number} [timeout=5000] - Timeout in ms
+ * @returns {Promise<any>} Event data
+ */
+function waitForEvent(mesh, eventName, timeout = 5000) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`Timeout waiting for event: ${eventName}`));
+    }, timeout);
+
+    mesh.once(eventName, (data) => {
+      clearTimeout(timer);
+      resolve(data);
+    });
+  });
+}
+
+// Export helpers
+module.exports = {
+  createTestMesh,
+  createTestPair,
+  createTestNetwork,
+  cleanupTestMeshes,
+  waitForEvent
+};
+
+// Demo if run directly
+if (require.main === module) {
+  (async () => {
+    console.log('Test Helper Demo\n');
+
+    // Demo: Create a test pair
+    console.log('1. Creating test pair...');
+    const { alice, bob, aliceTransport, bobTransport } = await createTestPair();
+    console.log('   Alice state:', alice.getState());
+    console.log('   Bob state:', bob.getState());
+
+    // Demo: Send message
+    console.log('\n2. Sending broadcast...');
+    alice.sendBroadcast('Test message');
+
+    // Demo: Create network
+    console.log('\n3. Creating 4-node chain network...');
+    const network = await createTestNetwork(4, 'chain');
+    console.log(`   Created ${network.length} nodes`);
+
+    // Cleanup
+    console.log('\n4. Cleaning up...');
+    await cleanupTestMeshes(alice, bob);
+    for (const node of network) {
+      await cleanupTestMeshes(node.mesh);
+    }
+
+    console.log('\nDemo complete!');
+  })().catch(console.error);
+}

package/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "react-native-ble-mesh",
+  "version": "1.0.1",
+  "description": "Production-ready BLE Mesh Network with Noise Protocol security",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "require": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./adapters": {
+      "require": "./src/transport/adapters/index.js",
+      "default": "./src/transport/adapters/index.js"
+    },
+    "./errors": {
+      "require": "./src/errors/index.js",
+      "default": "./src/errors/index.js"
+    },
+    "./crypto": {
+      "require": "./src/crypto/index.js",
+      "default": "./src/crypto/index.js"
+    },
+    "./utils": {
+      "require": "./src/utils/index.js",
+      "default": "./src/utils/index.js"
+    },
+    "./hooks": {
+      "require": "./src/hooks/index.js",
+      "default": "./src/hooks/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
+    "test:ci": "jest --ci --coverage --reporters=default --reporters=jest-junit",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "typecheck": "tsc --noEmit",
+    "docs": "jsdoc -c jsdoc.json",
+    "validate": "npm run lint && npm test",
+    "prepublishOnly": "npm run validate",
+    "preversion": "npm run validate",
+    "version": "npm run docs && git add -A docs",
+    "postversion": "git push && git push --tags",
+    "release": "npm version patch && npm publish",
+    "release:minor": "npm version minor && npm publish",
+    "release:major": "npm version major && npm publish",
+    "size": "node -e \"const s=require('fs').statSync('src/index.js');console.log('Index size:',s.size,'bytes')\"",
+    "example:node": "node examples/node-quickstart/index.js",
+    "example:chat": "node examples/node-chat/chat.js"
+  },
+  "keywords": [
+    "bluetooth",
+    "ble",
+    "mesh",
+    "p2p",
+    "peer-to-peer",
+    "noise-protocol",
+    "encryption",
+    "react-native",
+    "node",
+    "offline-first",
+    "x25519",
+    "chacha20-poly1305"
+  ],
+  "author": "Suhail Taj Shaik",
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "jsdoc": "^4.0.4",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@abandonware/noble": ">=1.9.0",
+    "react-native-ble-plx": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native-ble-plx": {
+      "optional": true
+    },
+    "@abandonware/noble": {
+      "optional": true
+    }
+  },
+  "files": [
+    "src",
+    "docs",
+    "examples",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/suhailtajshaik/react-native-ble-mesh.git"
+  },
+  "bugs": {
+    "url": "https://github.com/suhailtajshaik/react-native-ble-mesh/issues"
+  },
+  "homepage": "https://github.com/suhailtajshaik/react-native-ble-mesh#readme"
+}

package/src/constants/audio.js

@@ -0,0 +1,130 @@
+/**
+ * @fileoverview Audio constants for LC3 codec and audio streaming
+ * @module constants/audio
+ */
+
+'use strict';
+
+/**
+ * LC3 codec configuration
+ * @constant {Object}
+ */
+const LC3_CONFIG = Object.freeze({
+  /** Supported sample rates (Hz) */
+  SAMPLE_RATES: [16000, 24000, 32000, 48000],
+  /** Default sample rate for voice (optimized for speech) */
+  DEFAULT_SAMPLE_RATE: 16000,
+  /** Supported frame durations (ms) */
+  FRAME_DURATIONS: [7.5, 10],
+  /** Default frame duration */
+  DEFAULT_FRAME_DURATION_MS: 10,
+  /** Bit rate presets (bps) */
+  BIT_RATES: {
+    LOW: 16000,
+    MEDIUM: 24000,
+    HIGH: 32000
+  },
+  /** Default bit rate for voice */
+  DEFAULT_BIT_RATE: 24000,
+  /** Channels */
+  CHANNELS: {
+    MONO: 1,
+    STEREO: 2
+  },
+  /** Default channel count (mono for voice) */
+  DEFAULT_CHANNELS: 1
+});
+
+/**
+ * Audio quality presets
+ * @constant {Object.<string, Object>}
+ */
+const AUDIO_QUALITY = Object.freeze({
+  LOW: {
+    sampleRate: 16000,
+    bitRate: 16000,
+    frameMs: 10,
+    channels: 1
+  },
+  MEDIUM: {
+    sampleRate: 16000,
+    bitRate: 24000,
+    frameMs: 10,
+    channels: 1
+  },
+  HIGH: {
+    sampleRate: 24000,
+    bitRate: 32000,
+    frameMs: 10,
+    channels: 1
+  }
+});
+
+/**
+ * Voice message configuration
+ * @constant {Object}
+ */
+const VOICE_MESSAGE_CONFIG = Object.freeze({
+  /** Maximum voice message duration in seconds */
+  MAX_DURATION_SEC: 300,
+  /** Maximum voice message size in bytes (512KB) */
+  MAX_SIZE_BYTES: 512 * 1024,
+  /** Chunk size for voice message data (fits BLE MTU) */
+  CHUNK_SIZE: 180,
+  /** Voice message assembly timeout in milliseconds */
+  TIMEOUT_MS: 120000,
+  /** Voice message header size */
+  HEADER_SIZE: 51
+});
+
+/**
+ * Audio streaming configuration
+ * @constant {Object}
+ */
+const AUDIO_STREAM_CONFIG = Object.freeze({
+  /** Default jitter buffer size in frames */
+  JITTER_BUFFER_FRAMES: 5,
+  /** Maximum jitter buffer size in frames */
+  MAX_JITTER_BUFFER_FRAMES: 20,
+  /** Frame timeout in milliseconds */
+  FRAME_TIMEOUT_MS: 100,
+  /** Maximum consecutive dropped frames before quality event */
+  MAX_DROPPED_FRAMES: 10,
+  /** Session timeout in milliseconds */
+  SESSION_TIMEOUT_MS: 60000,
+  /** Audio frame header size */
+  FRAME_HEADER_SIZE: 8
+});
+
+/**
+ * Audio session states
+ * @constant {Object.<string, string>}
+ */
+const AUDIO_SESSION_STATE = Object.freeze({
+  IDLE: 'idle',
+  REQUESTING: 'requesting',
+  PENDING: 'pending',
+  ACTIVE: 'active',
+  PAUSED: 'paused',
+  ENDING: 'ending',
+  ENDED: 'ended',
+  FAILED: 'failed'
+});
+
+/**
+ * Audio codec types
+ * @constant {Object.<string, number>}
+ */
+const AUDIO_CODEC_TYPE = Object.freeze({
+  LC3: 0x01,
+  OPUS: 0x02
+});
+
+module.exports = {
+  LC3_CONFIG,
+  AUDIO_QUALITY,
+  VOICE_MESSAGE_CONFIG,
+  AUDIO_STREAM_CONFIG,
+  AUDIO_SESSION_STATE,
+  AUDIO_CODEC_TYPE
+};

package/src/constants/ble.js

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview Bluetooth Low Energy constants
+ * @module constants/ble
+ */
+
+'use strict';
+
+/**
+ * Nordic UART Service UUID
+ * Standard UUID for BLE serial communication
+ * @constant {string}
+ */
+const BLE_SERVICE_UUID = '6E400001-B5A3-F393-E0A9-E50E24DCCA9E';
+
+/**
+ * Nordic UART TX Characteristic UUID
+ * Used for writing data to peripheral
+ * @constant {string}
+ */
+const BLE_CHARACTERISTIC_TX = '6E400002-B5A3-F393-E0A9-E50E24DCCA9E';
+
+/**
+ * Nordic UART RX Characteristic UUID
+ * Used for receiving data from peripheral
+ * @constant {string}
+ */
+const BLE_CHARACTERISTIC_RX = '6E400003-B5A3-F393-E0A9-E50E24DCCA9E';
+
+/**
+ * Default MTU (Maximum Transmission Unit) size
+ * @constant {number}
+ */
+const DEFAULT_MTU = 23;
+
+/**
+ * Maximum MTU size for BLE 4.2+
+ * @constant {number}
+ */
+const MAX_MTU = 512;
+
+/**
+ * Power mode configurations
+ * @constant {Object.<string, Object>}
+ */
+const POWER_MODE = Object.freeze({
+  /**
+   * High performance mode
+   * Best responsiveness, highest power consumption
+   */
+  PERFORMANCE: Object.freeze({
+    scanInterval: 1000,
+    scanWindow: 500,
+    advInterval: 100,
+    connectionInterval: 7.5
+  }),
+  /**
+   * Balanced mode
+   * Good balance between responsiveness and power
+   */
+  BALANCED: Object.freeze({
+    scanInterval: 5000,
+    scanWindow: 1000,
+    advInterval: 500,
+    connectionInterval: 30
+  }),
+  /**
+   * Power saver mode
+   * Minimum power consumption, slower responsiveness
+   */
+  POWER_SAVER: Object.freeze({
+    scanInterval: 30000,
+    scanWindow: 2000,
+    advInterval: 1000,
+    connectionInterval: 100
+  })
+});
+
+/**
+ * Bluetooth adapter states
+ * @constant {Object.<string, string>}
+ */
+const BLUETOOTH_STATE = Object.freeze({
+  UNKNOWN: 'unknown',
+  RESETTING: 'resetting',
+  UNSUPPORTED: 'unsupported',
+  UNAUTHORIZED: 'unauthorized',
+  POWERED_OFF: 'poweredOff',
+  POWERED_ON: 'poweredOn'
+});
+
+/**
+ * Scan modes
+ * @constant {Object.<string, number>}
+ */
+const SCAN_MODE = Object.freeze({
+  LOW_POWER: 0,
+  BALANCED: 1,
+  LOW_LATENCY: 2,
+  OPPORTUNISTIC: -1
+});
+
+module.exports = {
+  BLE_SERVICE_UUID,
+  BLE_CHARACTERISTIC_TX,
+  BLE_CHARACTERISTIC_RX,
+  DEFAULT_MTU,
+  MAX_MTU,
+  POWER_MODE,
+  BLUETOOTH_STATE,
+  SCAN_MODE
+};

package/src/constants/crypto.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Cryptographic constants
+ * @module constants/crypto
+ */
+
+'use strict';
+
+/**
+ * Cryptographic configuration
+ * @constant {Object.<string, number|string>}
+ */
+const CRYPTO_CONFIG = Object.freeze({
+  /** Key size in bytes (256 bits) */
+  KEY_SIZE: 32,
+  /** Nonce size in bytes (96 bits) */
+  NONCE_SIZE: 12,
+  /** Authentication tag size in bytes (128 bits) */
+  TAG_SIZE: 16,
+  /** Public key size in bytes (256 bits) */
+  PUBLIC_KEY_SIZE: 32,
+  /** Hash output size in bytes (256 bits) */
+  HASH_SIZE: 32,
+  /** HMAC block size in bytes */
+  HMAC_BLOCK_SIZE: 64,
+  /** Maximum nonce value before rekey */
+  MAX_NONCE: Number.MAX_SAFE_INTEGER
+});
+
+/**
+ * Noise Protocol name
+ * XX pattern with X25519, ChaChaPoly, and SHA256
+ * @constant {string}
+ */
+const NOISE_PROTOCOL_NAME = 'Noise_XX_25519_ChaChaPoly_SHA256';
+
+/**
+ * Noise handshake states
+ * @constant {Object.<string, string>}
+ */
+const NOISE_HANDSHAKE_STATE = Object.freeze({
+  INITIAL: 'initial',
+  AWAITING_MESSAGE_1: 'awaitingMessage1',
+  AWAITING_MESSAGE_2: 'awaitingMessage2',
+  AWAITING_MESSAGE_3: 'awaitingMessage3',
+  COMPLETE: 'complete',
+  FAILED: 'failed'
+});
+
+module.exports = {
+  CRYPTO_CONFIG,
+  NOISE_PROTOCOL_NAME,
+  NOISE_HANDSHAKE_STATE
+};