@dbs-portal/tool-mock/dist/factories/data-generators.js

API mocking toolkit using MSW for DBS Portal development workflows

/**
 * Data generation utilities for creating realistic mock data
 */
import { v4 as uuidv4 } from 'uuid';
import { getRandom } from './base';
/**
 * Generate a UUID
 */
export function generateId() {
    return uuidv4();
}
/**
 * Generate a random integer between min and max (inclusive)
 */
export function generateNumber(min = 0, max = 100, decimals = 0) {
    const random = getRandom() * (max - min) + min;
    return decimals > 0 ? Number(random.toFixed(decimals)) : Math.floor(random);
}
/**
 * Generate a random number within a range
 */
export function generateNumberInRange(options) {
    return generateNumber(options.min, options.max, options.decimals);
}
/**
 * Generate a random boolean with optional probability
 */
export function generateBoolean(probability = 0.5) {
    return getRandom() < probability;
}
/**
 * Generate a random string
 */
export function generateString(minLength = 5, maxLength = 20, charset = 'alphanumeric') {
    const length = generateNumber(minLength, maxLength);
    let chars = '';
    switch (charset) {
        case 'alpha':
            chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
            break;
        case 'numeric':
            chars = '0123456789';
            break;
        case 'alphanumeric':
            chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
            break;
        case 'ascii':
            chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+-=[]{}|;:,.<>?';
            break;
    }
    let result = '';
    for (let i = 0; i < length; i++) {
        result += chars.charAt(Math.floor(getRandom() * chars.length));
    }
    return result;
}
/**
 * Generate a string with specific options
 */
export function generateStringWithOptions(options) {
    const length = generateNumber(options.minLength, options.maxLength);
    let chars = '';
    switch (options.charset) {
        case 'alpha':
            chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
            break;
        case 'numeric':
            chars = '0123456789';
            break;
        case 'alphanumeric':
            chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
            break;
        case 'ascii':
            chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+-=[]{}|;:,.<>?';
            break;
        case 'custom':
            chars = options.customChars || 'abcdefghijklmnopqrstuvwxyz';
            break;
        default:
            chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    }
    if (options.includeSpaces) {
        chars += ' ';
    }
    let result = '';
    for (let i = 0; i < length; i++) {
        result += chars.charAt(Math.floor(getRandom() * chars.length));
    }
    return result;
}
/**
 * Generate a random date within a range
 */
export function generateDate(start = new Date(2020, 0, 1), end = new Date(), format = 'iso') {
    const startDate = typeof start === 'string' ? new Date(start) : start;
    const endDate = typeof end === 'string' ? new Date(end) : end;
    const randomTime = startDate.getTime() + getRandom() * (endDate.getTime() - startDate.getTime());
    const randomDate = new Date(randomTime);
    switch (format) {
        case 'iso':
            return randomDate.toISOString();
        case 'timestamp':
            return randomDate.getTime();
        case 'date':
            return randomDate;
        default:
            return randomDate.toISOString();
    }
}
/**
 * Generate a date within a range with options
 */
export function generateDateInRange(options) {
    return generateDate(options.start, options.end, options.format);
}
/**
 * Generate a random email address
 */
export function generateEmail(domain = 'example.com') {
    const username = generateString(5, 12, 'alpha').toLowerCase();
    return `${username}@${domain}`;
}
/**
 * Generate a random name
 */
export function generateName(type = 'full') {
    const firstNames = [
        'John', 'Jane', 'Michael', 'Sarah', 'David', 'Emily', 'Robert', 'Jessica',
        'William', 'Ashley', 'James', 'Amanda', 'Christopher', 'Stephanie', 'Daniel',
        'Melissa', 'Matthew', 'Nicole', 'Anthony', 'Elizabeth', 'Mark', 'Helen',
        'Donald', 'Deborah', 'Steven', 'Rachel', 'Paul', 'Carolyn', 'Andrew', 'Janet'
    ];
    const lastNames = [
        'Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis',
        'Rodriguez', 'Martinez', 'Hernandez', 'Lopez', 'Gonzalez', 'Wilson', 'Anderson',
        'Thomas', 'Taylor', 'Moore', 'Jackson', 'Martin', 'Lee', 'Perez', 'Thompson',
        'White', 'Harris', 'Sanchez', 'Clark', 'Ramirez', 'Lewis', 'Robinson'
    ];
    const firstName = firstNames[Math.floor(getRandom() * firstNames.length)] || 'John';
    const lastName = lastNames[Math.floor(getRandom() * lastNames.length)] || 'Doe';
    switch (type) {
        case 'first':
            return firstName;
        case 'last':
            return lastName;
        case 'full':
        default:
            return `${firstName} ${lastName}`;
    }
}
/**
 * Generate a random phone number
 */
export function generatePhoneNumber(format = '+1-XXX-XXX-XXXX') {
    return format.replace(/X/g, () => generateNumber(0, 9).toString());
}
/**
 * Generate a random URL
 */
export function generateUrl(protocol = 'https') {
    const domains = ['example.com', 'test.org', 'demo.net', 'sample.io', 'mock.dev'];
    const paths = ['', '/api', '/docs', '/admin', '/dashboard', '/profile', '/settings'];
    const domain = domains[Math.floor(getRandom() * domains.length)];
    const path = paths[Math.floor(getRandom() * paths.length)];
    return `${protocol}://${domain}${path}`;
}
/**
 * Generate a random color
 */
export function generateColor(format = 'hex') {
    switch (format) {
        case 'hex':
            return `#${Math.floor(getRandom() * 16777215).toString(16).padStart(6, '0')}`;
        case 'rgb':
            const r = generateNumber(0, 255);
            const g = generateNumber(0, 255);
            const b = generateNumber(0, 255);
            return `rgb(${r}, ${g}, ${b})`;
        case 'hsl':
            const h = generateNumber(0, 360);
            const s = generateNumber(0, 100);
            const l = generateNumber(0, 100);
            return `hsl(${h}, ${s}%, ${l}%)`;
        default:
            return generateColor('hex');
    }
}
/**
 * Generate a random array
 */
export function generateArray(options) {
    const length = generateNumber(options.minLength, options.maxLength);
    const items = [];
    const usedItems = options.unique ? new Set() : null;
    for (let i = 0; i < length; i++) {
        let item = options.itemGenerator();
        if (options.unique && usedItems) {
            const itemKey = JSON.stringify(item);
            let attempts = 0;
            while (usedItems.has(itemKey) && attempts < 100) {
                item = options.itemGenerator();
                attempts++;
            }
            usedItems.add(JSON.stringify(item));
        }
        items.push(item);
    }
    return items;
}
/**
 * Pick a random item from an array
 */
export function pickRandom(items) {
    if (items.length === 0) {
        throw new Error('Cannot pick from empty array');
    }
    const item = items[Math.floor(getRandom() * items.length)];
    if (item === undefined) {
        throw new Error('Failed to pick item from array');
    }
    return item;
}
/**
 * Pick multiple random items from an array
 */
export function pickRandomMultiple(items, count, unique = true) {
    if (count >= items.length) {
        return [...items];
    }
    const result = [];
    const usedIndices = unique ? new Set() : null;
    for (let i = 0; i < count; i++) {
        let index = Math.floor(getRandom() * items.length);
        if (unique && usedIndices) {
            let attempts = 0;
            while (usedIndices.has(index) && attempts < 100) {
                index = Math.floor(getRandom() * items.length);
                attempts++;
            }
            usedIndices.add(index);
        }
        const item = items[index];
        if (item !== undefined) {
            result.push(item);
        }
    }
    return result;
}
/**
 * Generate a random person
 */
export function generatePerson(options = {}) {
    const gender = options.gender || pickRandom(['male', 'female', 'other']);
    const firstName = generateName('first');
    const lastName = generateName('last');
    const age = options.ageRange
        ? generateNumber(options.ageRange[0], options.ageRange[1])
        : generateNumber(18, 80);
    return {
        id: generateId(),
        firstName,
        lastName,
        fullName: `${firstName} ${lastName}`,
        email: generateEmail(),
        phone: generatePhoneNumber(),
        gender,
        age,
        dateOfBirth: generateDate(new Date(new Date().getFullYear() - age - 1, 0, 1), new Date(new Date().getFullYear() - age, 11, 31)),
        nationality: options.nationality || 'US',
        avatar: options.includeAvatar ? `https://api.dicebear.com/7.x/avataaars/svg?seed=${firstName}${lastName}` : undefined,
    };
}
/**
 * Generate a random company
 */
export function generateCompany(options = {}) {
    const companyNames = [
        'Tech Solutions', 'Digital Innovations', 'Global Systems', 'Smart Technologies',
        'Future Enterprises', 'Advanced Solutions', 'Dynamic Systems', 'Innovative Labs',
        'Next Generation', 'Modern Solutions', 'Elite Technologies', 'Premier Systems'
    ];
    const suffixes = ['Inc', 'LLC', 'Corp', 'Ltd', 'Co'];
    const industries = [
        'Technology', 'Healthcare', 'Finance', 'Education', 'Manufacturing',
        'Retail', 'Consulting', 'Media', 'Transportation', 'Energy'
    ];
    const name = pickRandom(companyNames);
    const suffix = pickRandom(suffixes);
    const industry = options.industry || pickRandom(industries);
    return {
        id: generateId(),
        name: `${name} ${suffix}`,
        industry,
        size: options.size || pickRandom(['startup', 'small', 'medium', 'large', 'enterprise']),
        founded: generateNumber(1950, new Date().getFullYear()),
        website: generateUrl(),
        email: generateEmail(`${name.toLowerCase().replace(' ', '')}.com`),
        phone: generatePhoneNumber(),
        logo: options.includeLogo ? `https://api.dicebear.com/7.x/initials/svg?seed=${name}` : undefined,
    };
}
/**
 * Generate a random address
 */
export function generateAddress(options = {}) {
    const streets = [
        'Main St', 'Oak Ave', 'Park Rd', 'First St', 'Second St', 'Third St',
        'Elm St', 'Washington Ave', 'Lincoln Blvd', 'Madison Dr', 'Jefferson Way'
    ];
    const cities = [
        'Springfield', 'Franklin', 'Georgetown', 'Madison', 'Washington',
        'Arlington', 'Richmond', 'Fairview', 'Salem', 'Bristol'
    ];
    const states = [
        'CA', 'NY', 'TX', 'FL', 'IL', 'PA', 'OH', 'GA', 'NC', 'MI'
    ];
    const countries = ['US', 'CA', 'UK', 'DE', 'FR', 'AU', 'JP'];
    const streetNumber = generateNumber(1, 9999);
    const street = pickRandom(streets);
    const city = options.city || pickRandom(cities);
    const state = options.state || pickRandom(states);
    const country = options.country || pickRandom(countries);
    const zipCode = generateString(5, 5, 'numeric');
    const address = {
        id: generateId(),
        street: `${streetNumber} ${street}`,
        city,
        state,
        country,
        zipCode,
        full: `${streetNumber} ${street}, ${city}, ${state} ${zipCode}, ${country}`,
    };
    if (options.includeCoordinates) {
        return {
            ...address,
            coordinates: {
                latitude: generateNumber(-90, 90, 6),
                longitude: generateNumber(-180, 180, 6),
            },
        };
    }
    return address;
}
//# sourceMappingURL=data-generators.js.map