@nitronjs/framework 0.1.22 → 0.1.23

package/lib/Faker/Faker.js

@@ -0,0 +1,812 @@
+import * as PersonData from './Data/Person.js';
+import * as AddressData from './Data/Address.js';
+import * as InternetData from './Data/Internet.js';
+import * as CompanyData from './Data/Company.js';
+import * as LoremData from './Data/Lorem.js';
+import * as FinanceData from './Data/Finance.js';
+import * as ColorData from './Data/Color.js';
+import * as DateData from './Data/Date.js';
+import * as PhoneData from './Data/Phone.js';
+
+class FakerClass {
+
+    #usedValues = new Map();
+    #allowDuplicates = false;
+    #maxAttempts = 1000;
+
+    constructor() {
+        this.#usedValues = new Map();
+        this.#allowDuplicates = false;
+    }
+
+    allowDuplicates() {
+        const instance = new FakerClass();
+        instance.#allowDuplicates = true;
+        return instance;
+    }
+
+    reset() {
+        this.#usedValues.clear();
+        return this;
+    }
+
+    #random(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+
+    #randomFloat(min, max, decimals = 2) {
+        const value = Math.random() * (max - min) + min;
+        return parseFloat(value.toFixed(decimals));
+    }
+
+    #pick(array) {
+        return array[this.#random(0, array.length - 1)];
+    }
+
+    #pickMultiple(array, count) {
+        const shuffled = [...array].sort(() => Math.random() - 0.5);
+        return shuffled.slice(0, Math.min(count, array.length));
+    }
+
+    #unique(key, generator) {
+        if (this.#allowDuplicates) {
+            return generator();
+        }
+
+        if (!this.#usedValues.has(key)) {
+            this.#usedValues.set(key, new Set());
+        }
+
+        const used = this.#usedValues.get(key);
+        let attempts = 0;
+
+        while (attempts < this.#maxAttempts) {
+            const value = generator();
+            if (!used.has(value)) {
+                used.add(value);
+                return value;
+            }
+            attempts++;
+        }
+
+        throw new Error(`Faker: Could not generate unique value for "${key}" after ${this.#maxAttempts} attempts`);
+    }
+
+    // ==================== PERSON ====================
+
+    firstName(gender) {
+        return this.#unique('firstName', () => {
+            if (gender === 'male') return this.#pick(PersonData.firstNamesMale);
+            if (gender === 'female') return this.#pick(PersonData.firstNamesFemale);
+            return this.#pick([...PersonData.firstNamesMale, ...PersonData.firstNamesFemale]);
+        });
+    }
+
+    lastName() {
+        return this.#unique('lastName', () => this.#pick(PersonData.lastNames));
+    }
+
+    fullName(gender) {
+        return this.#unique('fullName', () => `${this.firstName(gender)} ${this.lastName()}`);
+    }
+
+    gender() {
+        return this.#pick(PersonData.genders);
+    }
+
+    prefix(gender) {
+        if (gender === 'male') return this.#pick(PersonData.prefixes.male);
+        if (gender === 'female') return this.#pick(PersonData.prefixes.female);
+        return this.#pick([...PersonData.prefixes.male, ...PersonData.prefixes.female]);
+    }
+
+    suffix() {
+        return this.#pick(PersonData.suffixes);
+    }
+
+    age(min = 18, max = 80) {
+        return this.#random(min, max);
+    }
+
+    birthDate(minAge = 18, maxAge = 80) {
+        const today = new Date();
+        const age = this.#random(minAge, maxAge);
+        const year = today.getFullYear() - age;
+        const month = this.#random(0, 11);
+        const day = this.#random(1, 28);
+        return new Date(year, month, day);
+    }
+
+    jobTitle() {
+        return this.#pick(PersonData.jobTitles);
+    }
+
+    jobArea() {
+        return this.#pick(PersonData.jobAreas);
+    }
+
+    jobType() {
+        return this.#pick(PersonData.jobTypes);
+    }
+
+    // ==================== INTERNET ====================
+
+    email(firstName, lastName) {
+        return this.#unique('email', () => {
+            const fn = (firstName || this.firstName()).toLowerCase().replace(/[^a-z]/g, '');
+            const ln = (lastName || this.lastName()).toLowerCase().replace(/[^a-z]/g, '');
+            const provider = this.#pick(InternetData.emailProviders);
+            const separator = this.#pick(['', '.', '_', '-']);
+            const number = this.boolean() ? this.#random(1, 999) : '';
+            return `${fn}${separator}${ln}${number}@${provider}`;
+        });
+    }
+
+    username(firstName, lastName) {
+        return this.#unique('username', () => {
+            const fn = (firstName || this.firstName()).toLowerCase().replace(/[^a-z]/g, '');
+            const ln = (lastName || this.lastName()).toLowerCase().replace(/[^a-z]/g, '');
+            const separator = this.#pick(['', '.', '_', '-', '']);
+            const number = this.#random(1, 9999);
+            const patterns = [
+                `${fn}${separator}${ln}`,
+                `${fn}${number}`,
+                `${fn}${separator}${ln}${number}`,
+                `${ln}${separator}${fn}`,
+                `${fn.charAt(0)}${ln}${number}`
+            ];
+            return this.#pick(patterns);
+        });
+    }
+
+    password(length = 12, options = {}) {
+        const lowercase = 'abcdefghijklmnopqrstuvwxyz';
+        const uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        const numbers = '0123456789';
+        const symbols = '!@#$%^&*()_+-=[]{}|;:,.<>?';
+
+        let chars = lowercase;
+        if (options.uppercase !== false) chars += uppercase;
+        if (options.numbers !== false) chars += numbers;
+        if (options.symbols === true) chars += symbols;
+
+        let password = '';
+        for (let i = 0; i < length; i++) {
+            password += chars.charAt(this.#random(0, chars.length - 1));
+        }
+        return password;
+    }
+
+    url(protocol = 'https') {
+        return this.#unique('url', () => {
+            const domain = this.domainName();
+            const path = this.boolean() ? `/${this.slug()}` : '';
+            return `${protocol}://${domain}${path}`;
+        });
+    }
+
+    domainName() {
+        return this.#unique('domainName', () => {
+            const word = this.#pick(LoremData.words).toLowerCase();
+            const suffix = this.#pick(InternetData.domainSuffixes);
+            return `${word}${suffix}`;
+        });
+    }
+
+    domainWord() {
+        return this.#pick(LoremData.words).toLowerCase();
+    }
+
+    domainSuffix() {
+        return this.#pick(InternetData.domainSuffixes);
+    }
+
+    ip() {
+        return `${this.#random(1, 255)}.${this.#random(0, 255)}.${this.#random(0, 255)}.${this.#random(1, 255)}`;
+    }
+
+    ipv6() {
+        const segments = [];
+        for (let i = 0; i < 8; i++) {
+            segments.push(this.#random(0, 65535).toString(16).padStart(4, '0'));
+        }
+        return segments.join(':');
+    }
+
+    mac(separator = ':') {
+        const segments = [];
+        for (let i = 0; i < 6; i++) {
+            segments.push(this.#random(0, 255).toString(16).padStart(2, '0').toUpperCase());
+        }
+        return segments.join(separator);
+    }
+
+    port() {
+        return this.#random(1024, 65535);
+    }
+
+    userAgent() {
+        return this.#pick(InternetData.userAgents);
+    }
+
+    browser() {
+        const browser = this.#pick(InternetData.browsers);
+        return {
+            name: browser.name,
+            version: this.#pick(browser.versions)
+        };
+    }
+
+    httpMethod() {
+        return this.#pick(InternetData.httpMethods);
+    }
+
+    httpStatusCode() {
+        return this.#pick(InternetData.httpStatusCodes);
+    }
+
+    mimeType() {
+        return this.#pick(InternetData.mimeTypes);
+    }
+
+    fileExtension(type) {
+        if (type && InternetData.fileExtensions[type]) {
+            return this.#pick(InternetData.fileExtensions[type]);
+        }
+        const allExtensions = Object.values(InternetData.fileExtensions).flat();
+        return this.#pick(allExtensions);
+    }
+
+    fileName(extension) {
+        const ext = extension || this.fileExtension();
+        const name = this.slug();
+        return `${name}.${ext}`;
+    }
+
+    slug(wordCount = 3) {
+        const words = this.#pickMultiple(LoremData.words, wordCount);
+        return words.join('-').toLowerCase();
+    }
+
+    // ==================== ADDRESS ====================
+
+    streetAddress() {
+        const number = this.#random(1, 9999);
+        const name = this.#pick(AddressData.streetNames);
+        const suffix = this.#pick(AddressData.streetSuffixes);
+        return `${number} ${name} ${suffix}`;
+    }
+
+    streetName() {
+        return `${this.#pick(AddressData.streetNames)} ${this.#pick(AddressData.streetSuffixes)}`;
+    }
+
+    city() {
+        return this.#pick(AddressData.cities);
+    }
+
+    state(abbreviated = false) {
+        const state = this.#pick(AddressData.states);
+        return abbreviated ? state.abbr : state.name;
+    }
+
+    stateAbbr() {
+        return this.state(true);
+    }
+
+    country(abbreviated = false) {
+        const country = this.#pick(AddressData.countries);
+        return abbreviated ? country.code : country.name;
+    }
+
+    countryCode() {
+        return this.country(true);
+    }
+
+    zipCode() {
+        return `${this.#random(10000, 99999)}`;
+    }
+
+    latitude(min = -90, max = 90) {
+        return this.#randomFloat(min, max, 6);
+    }
+
+    longitude(min = -180, max = 180) {
+        return this.#randomFloat(min, max, 6);
+    }
+
+    coordinates() {
+        return {
+            latitude: this.latitude(),
+            longitude: this.longitude()
+        };
+    }
+
+    direction() {
+        return this.#pick(AddressData.directions);
+    }
+
+    secondaryAddress() {
+        const type = this.#pick(AddressData.secondaryAddresses);
+        const number = this.#random(1, 999);
+        return `${type} ${number}`;
+    }
+
+    fullAddress() {
+        return this.#unique('fullAddress', () => {
+            const street = this.streetAddress();
+            const city = this.city();
+            const state = this.stateAbbr();
+            const zip = this.zipCode();
+            return `${street}, ${city}, ${state} ${zip}`;
+        });
+    }
+
+    timeZone() {
+        return this.#pick(AddressData.timeZones);
+    }
+
+    // ==================== PHONE ====================
+
+    phoneNumber(format) {
+        const pattern = format || this.#pick(PhoneData.phoneFormats);
+        return pattern.replace(/#/g, () => this.#random(0, 9).toString());
+    }
+
+    phoneCountryCode() {
+        return this.#pick(PhoneData.countryCodes);
+    }
+
+    // ==================== COMPANY ====================
+
+    companyName() {
+        return this.#unique('companyName', () => {
+            const patterns = [
+                () => `${this.lastName()} ${this.#pick(CompanyData.companySuffixes)}`,
+                () => `${this.lastName()} and ${this.lastName()}`,
+                () => `${this.lastName()}, ${this.lastName()} and ${this.lastName()}`,
+                () => `${this.#pick(CompanyData.companyPrefixes)} ${this.lastName()}`,
+                () => `${this.lastName()} ${this.#pick(CompanyData.industries)}`
+            ];
+            return this.#pick(patterns)();
+        });
+    }
+
+    companySuffix() {
+        return this.#pick(CompanyData.companySuffixes);
+    }
+
+    industry() {
+        return this.#pick(CompanyData.industries);
+    }
+
+    catchPhrase() {
+        const adj = this.#pick(CompanyData.catchPhraseAdjectives);
+        const desc = this.#pick(CompanyData.catchPhraseDescriptors);
+        const noun = this.#pick(CompanyData.catchPhraseNouns);
+        return `${adj} ${desc} ${noun}`;
+    }
+
+    buzzword() {
+        return this.#pick(CompanyData.buzzwords);
+    }
+
+    department() {
+        return this.#pick(CompanyData.departments);
+    }
+
+    // ==================== LOREM ====================
+
+    word() {
+        return this.#pick(LoremData.words);
+    }
+
+    words(count = 5) {
+        return this.#pickMultiple(LoremData.words, count).join(' ');
+    }
+
+    sentence(wordCount) {
+        const count = wordCount || this.#random(5, 15);
+        const words = this.words(count);
+        return words.charAt(0).toUpperCase() + words.slice(1) + '.';
+    }
+
+    sentences(count = 3) {
+        const result = [];
+        for (let i = 0; i < count; i++) {
+            result.push(this.sentence());
+        }
+        return result.join(' ');
+    }
+
+    paragraph(sentenceCount) {
+        const count = sentenceCount || this.#random(3, 7);
+        return this.sentences(count);
+    }
+
+    paragraphs(count = 3, separator = '\n\n') {
+        const result = [];
+        for (let i = 0; i < count; i++) {
+            result.push(this.paragraph());
+        }
+        return result.join(separator);
+    }
+
+    text(length = 200) {
+        let result = '';
+        while (result.length < length) {
+            result += this.sentence() + ' ';
+        }
+        return result.trim().substring(0, length);
+    }
+
+    // ==================== DATE ====================
+
+    past(years = 1, refDate) {
+        const ref = refDate ? new Date(refDate) : new Date();
+        const min = ref.getTime() - years * 365 * 24 * 60 * 60 * 1000;
+        const max = ref.getTime();
+        return new Date(this.#random(min, max));
+    }
+
+    future(years = 1, refDate) {
+        const ref = refDate ? new Date(refDate) : new Date();
+        const min = ref.getTime();
+        const max = ref.getTime() + years * 365 * 24 * 60 * 60 * 1000;
+        return new Date(this.#random(min, max));
+    }
+
+    recent(days = 7) {
+        const now = new Date();
+        const min = now.getTime() - days * 24 * 60 * 60 * 1000;
+        return new Date(this.#random(min, now.getTime()));
+    }
+
+    soon(days = 7) {
+        const now = new Date();
+        const max = now.getTime() + days * 24 * 60 * 60 * 1000;
+        return new Date(this.#random(now.getTime(), max));
+    }
+
+    between(from, to) {
+        const fromTime = new Date(from).getTime();
+        const toTime = new Date(to).getTime();
+        return new Date(this.#random(Math.min(fromTime, toTime), Math.max(fromTime, toTime)));
+    }
+
+    month(abbreviated = false) {
+        const month = this.#pick(DateData.months);
+        return abbreviated ? month.abbr : month.name;
+    }
+
+    weekday(abbreviated = false) {
+        const day = this.#pick(DateData.weekdays);
+        return abbreviated ? day.abbr : day.name;
+    }
+
+    year(min, max) {
+        const minYear = min || new Date().getFullYear() - 50;
+        const maxYear = max || new Date().getFullYear();
+        return this.#random(minYear, maxYear);
+    }
+
+    // ==================== FINANCE ====================
+
+    amount(min = 0, max = 1000, decimals = 2, symbol = '$') {
+        const amount = this.#randomFloat(min, max, decimals);
+        return `${symbol}${amount.toFixed(decimals)}`;
+    }
+
+    currency() {
+        return this.#pick(FinanceData.currencies);
+    }
+
+    currencyCode() {
+        return this.currency().code;
+    }
+
+    currencySymbol() {
+        return this.currency().symbol;
+    }
+
+    creditCard(type) {
+        const cardType = type 
+            ? FinanceData.creditCardTypes.find(c => c.name.toLowerCase() === type.toLowerCase())
+            : this.#pick(FinanceData.creditCardTypes);
+
+        if (!cardType) {
+            throw new Error(`Unknown credit card type: ${type}`);
+        }
+
+        const prefix = this.#pick(cardType.prefix);
+        let number = prefix;
+        
+        while (number.length < cardType.length - 1) {
+            number += this.#random(0, 9);
+        }
+
+        // Luhn algorithm for check digit
+        let sum = 0;
+        let isEven = true;
+        for (let i = number.length - 1; i >= 0; i--) {
+            let digit = parseInt(number[i], 10);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9) digit -= 9;
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        const checkDigit = (10 - (sum % 10)) % 10;
+        number += checkDigit;
+
+        return number;
+    }
+
+    creditCardFormatted(type) {
+        const number = this.creditCard(type);
+        return number.replace(/(.{4})/g, '$1 ').trim();
+    }
+
+    creditCardCVV() {
+        return this.#random(100, 999).toString();
+    }
+
+    creditCardExpiry() {
+        const month = this.#random(1, 12).toString().padStart(2, '0');
+        const year = (new Date().getFullYear() + this.#random(1, 5)).toString().slice(-2);
+        return `${month}/${year}`;
+    }
+
+    iban(countryCode) {
+        const country = countryCode 
+            ? FinanceData.ibanCountryCodes.find(c => c.country === countryCode.toUpperCase())
+            : this.#pick(FinanceData.ibanCountryCodes);
+
+        if (!country) {
+            throw new Error(`Unknown IBAN country code: ${countryCode}`);
+        }
+
+        let iban = country.country;
+        const checkDigits = this.#random(10, 99).toString();
+        iban += checkDigits;
+
+        while (iban.length < country.length) {
+            iban += this.#random(0, 9);
+        }
+
+        return iban;
+    }
+
+    bic() {
+        const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        let bic = '';
+        for (let i = 0; i < 4; i++) bic += letters.charAt(this.#random(0, 25));
+        bic += this.countryCode();
+        for (let i = 0; i < 2; i++) bic += letters.charAt(this.#random(0, 25));
+        return bic;
+    }
+
+    transactionType() {
+        return this.#pick(FinanceData.transactionTypes);
+    }
+
+    accountType() {
+        return this.#pick(FinanceData.accountTypes);
+    }
+
+    accountNumber(length = 10) {
+        let number = '';
+        for (let i = 0; i < length; i++) {
+            number += this.#random(0, 9);
+        }
+        return number;
+    }
+
+    routingNumber() {
+        return this.accountNumber(9);
+    }
+
+    bitcoinAddress() {
+        const chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+        const prefix = this.#pick(['1', '3', 'bc1']);
+        let address = prefix;
+        const length = prefix === 'bc1' ? 39 : 33;
+        while (address.length < length) {
+            address += chars.charAt(this.#random(0, chars.length - 1));
+        }
+        return address;
+    }
+
+    ethereumAddress() {
+        const chars = '0123456789abcdef';
+        let address = '0x';
+        for (let i = 0; i < 40; i++) {
+            address += chars.charAt(this.#random(0, 15));
+        }
+        return address;
+    }
+
+    cryptoCurrency() {
+        return this.#pick(FinanceData.cryptoCurrencies);
+    }
+
+    // ==================== COLOR ====================
+
+    colorName() {
+        return this.#pick(ColorData.colorNames);
+    }
+
+    hexColor() {
+        const hex = this.#random(0, 16777215).toString(16).padStart(6, '0');
+        return `#${hex}`;
+    }
+
+    rgbColor() {
+        return {
+            r: this.#random(0, 255),
+            g: this.#random(0, 255),
+            b: this.#random(0, 255)
+        };
+    }
+
+    rgbString() {
+        const { r, g, b } = this.rgbColor();
+        return `rgb(${r}, ${g}, ${b})`;
+    }
+
+    rgbaString(alpha) {
+        const { r, g, b } = this.rgbColor();
+        const a = alpha !== undefined ? alpha : this.#randomFloat(0, 1, 2);
+        return `rgba(${r}, ${g}, ${b}, ${a})`;
+    }
+
+    hslColor() {
+        return {
+            h: this.#random(0, 360),
+            s: this.#random(0, 100),
+            l: this.#random(0, 100)
+        };
+    }
+
+    hslString() {
+        const { h, s, l } = this.hslColor();
+        return `hsl(${h}, ${s}%, ${l}%)`;
+    }
+
+    cssColor() {
+        return this.#pick(ColorData.cssColors);
+    }
+
+    tailwindColor(color, shade) {
+        if (color && ColorData.tailwindColors[color]) {
+            const shades = ColorData.tailwindColors[color];
+            const index = shade ? Math.floor(shade / 100) - 1 : this.#random(0, 9);
+            return shades[Math.max(0, Math.min(9, index))];
+        }
+        const colors = Object.keys(ColorData.tailwindColors);
+        const randomColor = this.#pick(colors);
+        return this.#pick(ColorData.tailwindColors[randomColor]);
+    }
+
+    // ==================== IMAGE ====================
+
+    imageUrl(width = 640, height = 480, category) {
+        const categories = ['nature', 'city', 'technology', 'food', 'animals', 'people', 'abstract'];
+        const cat = category || this.#pick(categories);
+        return `https://picsum.photos/seed/${this.uuid().slice(0, 8)}/${width}/${height}`;
+    }
+
+    avatarUrl(size = 200) {
+        const styles = ['adventurer', 'avataaars', 'big-ears', 'bottts', 'croodles', 'fun-emoji', 'icons', 'identicon', 'initials', 'lorelei', 'micah', 'miniavs', 'open-peeps', 'personas', 'pixel-art', 'shapes', 'thumbs'];
+        const style = this.#pick(styles);
+        const seed = this.uuid().slice(0, 8);
+        return `https://api.dicebear.com/7.x/${style}/svg?seed=${seed}&size=${size}`;
+    }
+
+    placeholderUrl(width = 640, height = 480, text, bgColor, textColor) {
+        const bg = (bgColor || this.hexColor()).replace('#', '');
+        const fg = (textColor || (parseInt(bg, 16) > 8388607 ? '000000' : 'ffffff'));
+        const txt = text || `${width}x${height}`;
+        return `https://via.placeholder.com/${width}x${height}/${bg}/${fg}?text=${encodeURIComponent(txt)}`;
+    }
+
+    // ==================== UUID ====================
+
+    uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = this.#random(0, 15);
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+
+    // ==================== NUMBER ====================
+
+    int(min = 0, max = 100) {
+        return this.#random(min, max);
+    }
+
+    float(min = 0, max = 100, decimals = 2) {
+        return this.#randomFloat(min, max, decimals);
+    }
+
+    boolean(probability = 0.5) {
+        return Math.random() < probability;
+    }
+
+    arrayElement(array) {
+        return this.#pick(array);
+    }
+
+    arrayElements(array, count) {
+        return this.#pickMultiple(array, count || this.#random(1, array.length));
+    }
+
+    objectElement(obj) {
+        const keys = Object.keys(obj);
+        const key = this.#pick(keys);
+        return { key, value: obj[key] };
+    }
+
+    shuffle(array) {
+        return [...array].sort(() => Math.random() - 0.5);
+    }
+
+    // ==================== HELPERS ====================
+
+    maybe(callback, probability = 0.5) {
+        return this.boolean(probability) ? callback() : null;
+    }
+
+    times(count, callback) {
+        const results = [];
+        for (let i = 0; i < count; i++) {
+            results.push(callback(i));
+        }
+        return results;
+    }
+
+    oneOf(...values) {
+        return this.#pick(values);
+    }
+
+    weightedPick(items) {
+        const totalWeight = items.reduce((sum, item) => sum + (item.weight || 1), 0);
+        let random = Math.random() * totalWeight;
+        
+        for (const item of items) {
+            random -= item.weight || 1;
+            if (random <= 0) {
+                return item.value;
+            }
+        }
+        
+        return items[items.length - 1].value;
+    }
+
+    template(str, data = {}) {
+        return str.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (match, path) => {
+            const parts = path.split('.');
+            let value = this;
+
+            for (const part of parts) {
+                if (typeof value[part] === 'function') {
+                    value = value[part]();
+                } else if (data[part] !== undefined) {
+                    value = data[part];
+                } else {
+                    return match;
+                }
+            }
+
+            return value;
+        });
+    }
+
+}
+
+const Faker = new FakerClass();
+
+export default Faker;
+export { FakerClass };