react-native-uuid

You can use react-native-uuid by either using the default export for a unified interface or by importing specific versioned generators as named exports. This allows for a clean, modular approach to UUID generation in your React Native or Node.js projects.

Usage Patterns:

• Default Export: Access all methods via a single object (e.g., uuid.v4()).
• Named Exports: Import only the specific version you need (e.g., import { v4 } from 'react-native-uuid').

// Using default export
import uuid from 'react-native-uuid';
const id = uuid.v4();

// Using named exports
import { v4 } from 'react-native-uuid';
const id = v4();

The default export of the react-native-uuid module provides a comprehensive suite of UUID generation and manipulation utilities. It includes version-specific generators (v1, v3, v4, v5), validation tools, and parsing/unparsing capabilities for different UUID formats.

import uuid from 'react-native-uuid';

// Example usage of available properties:
const id = uuid.v4();
const isValid = uuid.validate(id);
const version = uuid.version(id);

The parse function converts a UUID string into an array of numbers (bytes). This is useful when you need to work with the raw byte representation of a UUID instead of its string format.

Parameters:

• s: The UUID string to be parsed.
• buf (optional): An existing number[] array to store the parsed bytes. If provided, the function will write into this buffer.
• offset (optional): The starting index in buf where the parsed bytes should be written.

Returns:

• A number[] containing the byte representation of the UUID.

// Basic usage
const bytes = parse('550e8400-e29b-41d4-a716-446655440000');

The v5 function generates a name-based UUID using the SHA-1 hashing algorithm. Unlike random UUIDs (like v4), v5 UUIDs are deterministic: providing the same value and namespace will always produce the same UUID. This is useful for creating unique identifiers based on existing data (e.g., a user ID or an email address).

import uuid from 'react-native-uuid';

// Example usage:
// Note: The namespace must be a valid UUID string or a byte array.
const namespace = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; // DNS namespace
const name = 'example.com';

const id = uuid.v5(name, namespace);
console.log(id); // Always returns the same UUID for these inputs

The regex module exports a default constant of type RegExp. This regular expression is used internally by the library for pattern matching and validation during UUID generation or parsing processes.

import { default as uuidRegex } from 'react-native-uuid/regex';

// uuidRegex is a RegExp instance used for UUID pattern matching
const isValid = uuidRegex.test(someUuidString);

Use the validate function to check if a given string is a valid UUID. It returns true if the string conforms to the UUID format, and false otherwise.

import { validate } from 'react-native-uuid';

const isValid = validate('123e4567-e89b-12d3-a456-426614174000'); // true
const isInvalid = validate('not-a-uuid'); // false

The v35 module provides a way to generate UUIDs following the version 3 (MD5-based) specification. It is initialized by providing a name, a version number, and a hashing function. Once initialized, it returns a GenerateUUID function that can be used to create UUIDs based on a specific value and namespace.

Note: The v35 function itself is a factory that returns the actual generator function.

// Example of how the v35 factory and GenerateUUID function are structured
// Note: Actual implementation requires providing a name, version, and hash function
const generate = v35('example-name', 3, (s) => md5(s));
const uuid = generate('my-value', 'my-namespace');

The unparse function converts an array of numbers (representing bytes) into a string. This is typically used to reconstruct a string representation from a raw buffer or byte array.

Parameters:

• buf: An array of numbers (number[]) representing the byte data.
• offset?: An optional number representing the starting index in the buffer from which to begin unparsing.

// Example usage (signature based on documentation)
const result = unparse([0x68, 0x65, 0x6c, 0x6c, 0x6f]); // returns "hello"

The stringify function converts a Uint8Array into its string representation. It allows you to specify an optional offset to start the conversion from a specific index within the array.

// Signature:
// const stringify(arr: Uint8Array, offset?: number): string

const result = stringify(myUint8Array, 0);

The v3 function generates a name-based UUID using the MD5 hashing algorithm. It requires a value (the name to hash) and a namespace (the UUID namespace to use). This is useful when you need to generate the same UUID every time for a specific input and namespace.

// Example usage of v3
// Note: Actual implementation requires importing 'v3' from 'react-native-uuid'
const uuid = v3('my-name-value', '6ba7b810-9dad-11d1-80b4-00c04fd430c8');

Use the v4 function to generate a version 4 UUID. This function can return either a formatted string or a raw number[] (byte array) depending on the arguments provided.

Parameters

• options? (string | V4Options): Configuration for the generator. If a string is provided, it is treated as a configuration option.
• buf? (number[]): An optional buffer of numbers to be used or populated.
• offset? (number): An optional offset for the buffer operations.

Return Values

• Returns a string (the standard UUID format) by default.
• Returns a number[] if a buffer is provided.

import { v4 } from 'react-native-uuid';

// Default usage: returns a UUID string
const uuid = v4();
console.log(uuid); // e.g., 'f47ac10b-58cc-4372-a567-0e02b2c3d479'