react-native-ble-mesh 1.0.1

package/src/utils/uuid.js

@@ -0,0 +1,145 @@
+'use strict';
+
+/**
+ * @fileoverview UUID generation and manipulation utilities
+ * @module utils/uuid
+ */
+
+const { randomBytes } = require('./bytes');
+const { bytesToHex, hexToBytes } = require('./encoding');
+
+/**
+ * UUID v4 regex pattern
+ * @private
+ */
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+/**
+ * Generates a UUID v4 (random)
+ * @returns {string} UUID string in format xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+ */
+function generateUUID() {
+  const bytes = randomBytes(16);
+
+  // Set version (4) in byte 6
+  bytes[6] = (bytes[6] & 0x0f) | 0x40;
+
+  // Set variant (10xx) in byte 8
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+
+  const hex = bytesToHex(bytes);
+
+  return (
+    `${hex.substring(0, 8)}-${
+      hex.substring(8, 12)}-${
+      hex.substring(12, 16)}-${
+      hex.substring(16, 20)}-${
+      hex.substring(20, 32)}`
+  );
+}
+
+/**
+ * Converts a UUID string to a 16-byte array
+ * @param {string} uuid - UUID string
+ * @returns {Uint8Array} 16-byte array
+ * @throws {Error} If UUID format is invalid
+ */
+function uuidToBytes(uuid) {
+  if (typeof uuid !== 'string') {
+    throw new Error('UUID must be a string');
+  }
+
+  // Remove dashes
+  const hex = uuid.replace(/-/g, '');
+
+  if (hex.length !== 32) {
+    throw new Error('Invalid UUID format');
+  }
+
+  return hexToBytes(hex);
+}
+
+/**
+ * Converts a 16-byte array to a UUID string
+ * @param {Uint8Array} bytes - 16-byte array
+ * @returns {string} UUID string
+ * @throws {Error} If bytes length is not 16
+ */
+function bytesToUuid(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new Error('Input must be a Uint8Array');
+  }
+
+  if (bytes.length !== 16) {
+    throw new Error('UUID must be exactly 16 bytes');
+  }
+
+  const hex = bytesToHex(bytes);
+
+  return (
+    `${hex.substring(0, 8)}-${
+      hex.substring(8, 12)}-${
+      hex.substring(12, 16)}-${
+      hex.substring(16, 20)}-${
+      hex.substring(20, 32)}`
+  );
+}
+
+/**
+ * Validates a UUID string format
+ * @param {string} uuid - UUID string to validate
+ * @returns {boolean} True if valid UUID v4 format
+ */
+function isValidUUID(uuid) {
+  if (typeof uuid !== 'string') {
+    return false;
+  }
+
+  return UUID_REGEX.test(uuid);
+}
+
+/**
+ * Generates a short ID (8 hex characters) for display purposes
+ * Not guaranteed to be unique, use for UI display only
+ * @returns {string} 8-character hex string
+ */
+function generateShortId() {
+  return bytesToHex(randomBytes(4));
+}
+
+/**
+ * Extracts the first 8 characters of a UUID for display
+ * @param {string} uuid - Full UUID string
+ * @returns {string} Shortened UUID
+ */
+function shortenUUID(uuid) {
+  if (typeof uuid !== 'string') {
+    return '';
+  }
+
+  return uuid.substring(0, 8);
+}
+
+/**
+ * Compares two UUIDs for equality (case-insensitive)
+ * @param {string} uuid1 - First UUID
+ * @param {string} uuid2 - Second UUID
+ * @returns {boolean} True if UUIDs are equal
+ */
+function compareUUID(uuid1, uuid2) {
+  if (typeof uuid1 !== 'string' || typeof uuid2 !== 'string') {
+    return false;
+  }
+
+  return uuid1.toLowerCase() === uuid2.toLowerCase();
+}
+
+module.exports = {
+  generateUUID,
+  uuidToBytes,
+  bytesToUuid,
+  isValidUUID,
+  generateShortId,
+  shortenUUID,
+  compareUUID
+};

package/src/utils/validation.js

@@ -0,0 +1,205 @@
+'use strict';
+
+/**
+ * @fileoverview Input validation utilities
+ * @module utils/validation
+ */
+
+const { ValidationError } = require('../errors');
+
+/**
+ * Validates that a value is a non-empty string
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {ValidationError} If value is not a valid string
+ */
+function validateString(value, name) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (typeof value !== 'string') {
+    throw ValidationError.invalidType(name, value, 'string');
+  }
+
+  if (value.length === 0) {
+    throw ValidationError.invalidArgument(name, value, { reason: 'String cannot be empty' });
+  }
+}
+
+/**
+ * Validates that a value is a Uint8Array with optional length check
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @param {number} [expectedLength] - Expected length (optional)
+ * @throws {ValidationError} If value is not a valid Uint8Array
+ */
+function validateBytes(value, name, expectedLength) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (!(value instanceof Uint8Array)) {
+    throw ValidationError.invalidType(name, value, 'Uint8Array');
+  }
+
+  if (expectedLength !== undefined && value.length !== expectedLength) {
+    throw ValidationError.invalidArgument(name, value, {
+      reason: `Expected ${expectedLength} bytes, got ${value.length}`
+    });
+  }
+}
+
+/**
+ * Validates that a value is a positive integer
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {ValidationError} If value is not a positive integer
+ */
+function validatePositiveInt(value, name) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (typeof value !== 'number' || !Number.isInteger(value)) {
+    throw ValidationError.invalidType(name, value, 'integer');
+  }
+
+  if (value <= 0) {
+    throw ValidationError.outOfRange(name, value, { min: 1 });
+  }
+}
+
+/**
+ * Validates that a value is one of the allowed values
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @param {Array} allowed - Array of allowed values
+ * @throws {ValidationError} If value is not in allowed list
+ */
+function validateEnum(value, name, allowed) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (!allowed.includes(value)) {
+    throw ValidationError.invalidArgument(name, value, {
+      allowed: allowed
+    });
+  }
+}
+
+/**
+ * Validates that a value is a non-negative integer
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {ValidationError} If value is not a non-negative integer
+ */
+function validateNonNegativeInt(value, name) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (typeof value !== 'number' || !Number.isInteger(value)) {
+    throw ValidationError.invalidType(name, value, 'integer');
+  }
+
+  if (value < 0) {
+    throw ValidationError.outOfRange(name, value, { min: 0 });
+  }
+}
+
+/**
+ * Validates that a value is a number within a range
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @param {number} min - Minimum value (inclusive)
+ * @param {number} max - Maximum value (inclusive)
+ * @throws {ValidationError} If value is not within range
+ */
+function validateRange(value, name, min, max) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (typeof value !== 'number' || Number.isNaN(value)) {
+    throw ValidationError.invalidType(name, value, 'number');
+  }
+
+  if (value < min || value > max) {
+    throw ValidationError.outOfRange(name, value, { min, max });
+  }
+}
+
+/**
+ * Validates that a value is a boolean
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {ValidationError} If value is not a boolean
+ */
+function validateBoolean(value, name) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (typeof value !== 'boolean') {
+    throw ValidationError.invalidType(name, value, 'boolean');
+  }
+}
+
+/**
+ * Validates that a value is a function
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {ValidationError} If value is not a function
+ */
+function validateFunction(value, name) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (typeof value !== 'function') {
+    throw ValidationError.invalidType(name, value, 'function');
+  }
+}
+
+/**
+ * Validates that a value is a plain object
+ * @param {*} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {ValidationError} If value is not a plain object
+ */
+function validateObject(value, name) {
+  if (value === undefined || value === null) {
+    throw ValidationError.missingArgument(name);
+  }
+
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw ValidationError.invalidType(name, value, 'object');
+  }
+}
+
+/**
+ * Validates an optional value (only if present)
+ * @param {*} value - Value to validate
+ * @param {function} validator - Validation function to apply
+ * @param {string} name - Name of the parameter for error messages
+ */
+function validateOptional(value, validator, name) {
+  if (value !== undefined && value !== null) {
+    validator(value, name);
+  }
+}
+
+module.exports = {
+  validateString,
+  validateBytes,
+  validatePositiveInt,
+  validateEnum,
+  validateNonNegativeInt,
+  validateRange,
+  validateBoolean,
+  validateFunction,
+  validateObject,
+  validateOptional
+};