@20syldev/api 3.5.0 → 4.0.0

package/src/modules/v4/domain.ts

@@ -0,0 +1,81 @@
+import { random, genIP } from './utils.js';
+
+export default function domain(): Record<string, unknown> {
+    const subdomains = [
+        'fr.',
+        'en.',
+        'docs.',
+        'api.',
+        'projects.',
+        'app.',
+        'web.',
+        'info.',
+        'dev.',
+        'shop.',
+        'blog.',
+        'support.',
+        'mail.',
+        'forum.',
+    ];
+    const domains = [
+        'example',
+        'site',
+        'test',
+        'demo',
+        'page',
+        'store',
+        'portfolio',
+        'platform',
+        'hub',
+        'network',
+        'service',
+        'cloud',
+        'solutions',
+        'company',
+    ];
+    const tlds = [
+        '.com',
+        '.fr',
+        '.eu',
+        '.dev',
+        '.net',
+        '.org',
+        '.io',
+        '.tech',
+        '.biz',
+        '.info',
+        '.co',
+        '.app',
+        '.store',
+        '.online',
+        '.shop',
+        '.tv',
+    ];
+
+    const domainName = `${random(domains)}${random(tlds)}`;
+    const fulldomain = `${random(subdomains)}${domainName}`;
+
+    const ips = Array.from({ length: Math.floor(Math.random() * 3) + 1 }, genIP);
+    const dns = Array.from({ length: Math.floor(Math.random() * 5) + 1 }, genIP);
+
+    return {
+        domain: domainName,
+        full_domain: fulldomain,
+        ip_address: ips,
+        ssl_certified: Math.random() > 0.5,
+        hosting_provider: random(['AWS', 'Bluehost', 'DigitalOcean', 'GitHub', 'HostGator', 'Render', 'SiteGround']),
+        dns_servers: dns,
+        dns_provider: random(['AWS Route 53', 'Cloudflare', 'GoDaddy', 'Google DNS', 'Namecheap']),
+        traffic: `${Math.floor(Math.random() * 10000)} visits/day`,
+        seo_score: Math.floor(Math.random() * 100),
+        page_rank: Math.floor(Math.random() * 10),
+        country: random(['Australia', 'Canada', 'France', 'Germany', 'India', 'Japan', 'UK', 'USA']),
+        website_type: random(['Blog', 'Community', 'Corporate', 'Educational', 'E-commerce', 'Personal', 'Portfolio']),
+        random_name: domainName.split('.')[0],
+        random_subdomain: fulldomain.split('.')[0],
+        random_tld: domainName.split('.').pop(),
+        backlinks_count: Math.floor(Math.random() * 1000),
+        creation_date: new Date(Date.now() - Math.floor(Math.random() * 10000000000)).toISOString(),
+        expiration_date: new Date(Date.now() + Math.floor(Math.random() * 10000000000)).toISOString(),
+    };
+}

package/src/modules/v4/hash.ts

@@ -0,0 +1,9 @@
+import { getHashes, createHash } from 'crypto';
+
+export default function hash(text: string, method: string): { method: string; hash: string } | { error: string } {
+    const methods = getHashes();
+    if (!methods.includes(method)) return { error: `Unsupported method. Use one of: ${methods.join(', ')}` };
+
+    const result = createHash(method).update(text).digest('hex');
+    return { method, hash: result };
+}

package/src/modules/v4/hyperplanning.ts

@@ -0,0 +1,58 @@
+import { formatDate } from './utils.js';
+import ical from 'ical.js';
+
+interface CalendarEvent {
+    summary: string[] | string;
+    subject?: string;
+    teacher?: string;
+    classes?: string[];
+    type?: string;
+    start: string;
+    end: string;
+}
+
+export default async function hyperplanning(url: string, detail?: string): Promise<CalendarEvent[]> {
+    const response = await fetch(url);
+
+    if (!response.ok || !(response.headers.get('content-type') || '').includes('text/calendar')) {
+        throw new Error('Invalid ICS file format.');
+    }
+
+    const events: CalendarEvent[] = new ical.Component(ical.parse(await response.text()))
+        .getAllSubcomponents('vevent')
+        .map((e: ical.Component) => {
+            const evt = new ical.Event(e);
+            const summary = (evt.summary || '').split(' ').filter((part: string) => part !== '-');
+            const start = formatDate(evt.startDate.toJSDate());
+            const end = formatDate(evt.endDate.toJSDate());
+
+            if (detail === 'full') {
+                const desc = (evt.description || '').split('\n').map((l: string) => l.trim());
+                const extract = (p: string) => (desc.find((l: string) => l.startsWith(p)) || '').replace(p, '').trim();
+
+                return {
+                    summary,
+                    subject: extract('Matière :'),
+                    teacher: extract('Enseignant :'),
+                    classes: extract('Promotions :')
+                        .split(', ')
+                        .map((c: string) => c.trim()),
+                    type: extract('Salle :') || undefined,
+                    start,
+                    end,
+                };
+            }
+
+            if (detail === 'list') return { summary, start, end };
+
+            return {
+                summary: evt.summary || '',
+                start,
+                end,
+            };
+        })
+        .sort((a: CalendarEvent, b: CalendarEvent) => new Date(a.start).getTime() - new Date(b.start).getTime())
+        .filter((e: CalendarEvent) => new Date(e.end) >= new Date());
+
+    return events;
+}

package/src/modules/v4/levenshtein.ts

@@ -0,0 +1,38 @@
+import { MAX_LEVENSHTEIN_LENGTH } from '../../constants.js';
+
+export default function levenshtein(str1: string, str2: string): { str1: string; str2: string; distance: number } {
+    if (!str1 || typeof str1 !== 'string') {
+        throw new Error('Please provide a valid first string');
+    }
+
+    if (!str2 || typeof str2 !== 'string') {
+        throw new Error('Please provide a valid second string');
+    }
+
+    if (str1.length > MAX_LEVENSHTEIN_LENGTH) {
+        throw new Error('First string exceeds 1000 characters');
+    }
+
+    if (str2.length > MAX_LEVENSHTEIN_LENGTH) {
+        throw new Error('Second string exceeds 1000 characters');
+    }
+
+    const m: number[][] = Array.from({ length: str1.length + 1 }, (_, i) => [i]);
+    for (let j = 0; j <= str2.length; j++) m[0]![j] = j;
+
+    for (let i = 1; i <= str1.length; i++) {
+        for (let j = 1; j <= str2.length; j++) {
+            m[i]![j] = Math.min(
+                m[i - 1]![j]! + 1,
+                m[i]![j - 1]! + 1,
+                m[i - 1]![j - 1]! + (str1[i - 1] !== str2[j - 1] ? 1 : 0),
+            );
+        }
+    }
+
+    return {
+        str1,
+        str2,
+        distance: m[str1.length]![str2.length]!,
+    };
+}

package/src/modules/v4/personal.ts

@@ -0,0 +1,147 @@
+import { random, randomNumber } from './utils.js';
+
+interface Person {
+    name: string;
+    social: string;
+    email: string;
+    country: string;
+}
+
+interface CountryInfo {
+    tel: string;
+    code: string;
+    lang: string;
+}
+
+export default function personal(): Record<string, unknown> {
+    const people: Person[] = [
+        { name: 'John Doe', social: 'john_doe', email: 'john@example.com', country: 'US' },
+        { name: 'Jane Martin', social: 'jane_martin', email: 'jane@example.com', country: 'FR' },
+        { name: 'Michael Johnson', social: 'mike_johnson', email: 'michael@example.com', country: 'UK' },
+        { name: 'Emily Davis', social: 'emily_davis', email: 'emily@example.com', country: 'ES' },
+        { name: 'Alexis Barbos', social: 'alexis_barbos', email: 'alexis@example.com', country: 'DE' },
+        { name: 'Sarah Williams', social: 'sarah_williams', email: 'sarah@example.com', country: 'IT' },
+        { name: 'Daniel Brown', social: 'daniel_brown', email: 'daniel@example.com', country: 'JP' },
+        { name: 'Sophia Wilson', social: 'sophia_wilson', email: 'sophia@example.com', country: 'BR' },
+        { name: 'James Taylor', social: 'james_taylor', email: 'james@example.com', country: 'CA' },
+        { name: 'Olivia Thomas', social: 'olivia_thomas', email: 'olivia@example.com', country: 'AU' },
+    ];
+
+    const countries: Record<string, CountryInfo> = {
+        US: { tel: '123-456-7890', code: '1', lang: 'English' },
+        FR: { tel: '06 78 90 12 34', code: '33', lang: 'French' },
+        UK: { tel: '7911 123456', code: '44', lang: 'English' },
+        ES: { tel: '678 901 234', code: '34', lang: 'Spanish' },
+        DE: { tel: '163 555 1584', code: '49', lang: 'German' },
+        IT: { tel: '345 678 9012', code: '39', lang: 'Italian' },
+        JP: { tel: '080-1234-5678', code: '81', lang: 'Japanese' },
+        BR: { tel: '(11) 98765-4321', code: '55', lang: 'Portuguese' },
+        CA: { tel: '416-123-4567', code: '1', lang: 'English' },
+        AU: { tel: '0412 345 678', code: '61', lang: 'English' },
+    };
+
+    const jobs = ['Writer', 'Artist', 'Musician', 'Explorer', 'Scientist', 'Engineer', 'Athlete', 'Doctor'];
+    const hobbies = ['Reading', 'Traveling', 'Gaming', 'Cooking', 'Fitness', 'Music', 'Photography', 'Writing'];
+    const cities = [
+        'New York',
+        'Paris',
+        'London',
+        'Madrid',
+        'Berlin',
+        'Rome',
+        'Tokyo',
+        'Los Angeles',
+        'Sydney',
+        'São Paulo',
+        'Toronto',
+    ];
+    const streets = ['Main St', '2nd Ave', 'Broadway', 'Park Lane', 'Elm St', 'Sunset Blvd', 'Maple St', 'Highland Rd'];
+
+    const card = Array.from({ length: 4 }, () => randomNumber(1000, 9999)).join(' ');
+    const cvc = randomNumber(100, 999);
+    const expiration = `${String(randomNumber(1, 12)).padStart(2, '0')}/${(new Date().getFullYear() + randomNumber(0, 3)).toString().slice(-2)}`;
+
+    const person = random(people);
+    const social = person.social;
+    const country = person.country;
+    const countryInfo = countries[country]!;
+    const phone = countryInfo.tel;
+    const lang = countryInfo.lang;
+
+    const age = randomNumber(18, 67);
+    const birthday = new Date(Date.now() - randomNumber(18, 67) * 365.25 * 24 * 60 * 60 * 1000).toISOString();
+
+    const emergencyContacts: { name: string; relationship: string; phone: string }[] = [];
+    const yearIncome = randomNumber(20000, 100000);
+    const subscriptions: string[] = [];
+    const pets: string[] = [];
+    const vehicles: string[] = [];
+    let civilStatus = 'Single';
+    let children = 0;
+
+    if (age >= 21 && Math.random() > 0.7) civilStatus = 'Married';
+    if (civilStatus === 'Married' && age >= 25) children = randomNumber(0, 3);
+
+    while (emergencyContacts.length < randomNumber(1, 3)) {
+        let emergencyContact = random(people);
+        while (
+            emergencyContact.email === person.email ||
+            emergencyContacts.some((e) => e.name === emergencyContact.name)
+        ) {
+            emergencyContact = random(people);
+        }
+        const emergencyPhone = `${randomNumber(100, 999)}-${randomNumber(100, 999)}-${randomNumber(1000, 9999)}`;
+        emergencyContacts.push({
+            name: emergencyContact.name,
+            relationship: random(['Spouse', 'Parent', 'Sibling', 'Friend']),
+            phone: `+${countryInfo.code} ${emergencyPhone}`,
+        });
+    }
+
+    while (subscriptions.length < randomNumber(1, 3)) {
+        const subscription = random(['Netflix', 'Spotify', 'Amazon Prime', 'Disney+', 'Hulu']);
+        if (!subscriptions.includes(subscription)) subscriptions.push(subscription);
+    }
+
+    while (pets.length < randomNumber(1, 3)) {
+        const pet = random(['Dog', 'Cat', 'Fish', 'Bird', 'None']);
+        if (!pets.includes(pet)) pets.push(pet);
+    }
+
+    while (vehicles.length < randomNumber(1, 3)) {
+        const vehicle = random(['Car', 'Bike', 'Motorcycle', 'Bus', 'None']);
+        if (!vehicles.includes(vehicle)) vehicles.push(vehicle);
+    }
+
+    return {
+        name: person.name,
+        email: person.email,
+        localisation: country,
+        phone: `+${countryInfo.code} ${phone}`,
+        job: random(jobs),
+        hobbies: random(hobbies),
+        language: lang,
+        card,
+        cvc,
+        expiration,
+        address: `${randomNumber(1, 9999)} ${random(streets)}, ${random(cities)}`,
+        birthday,
+        civil_status: civilStatus,
+        children,
+        vehicle: vehicles,
+        social_profiles: {
+            twitter: `@${social}`,
+            facebook: `facebook.com/${social}`,
+            linkedin: `linkedin.com/in/${social}`,
+            instagram: `instagram.com/${social}`,
+        },
+        year_income: `${yearIncome} USD/year`,
+        month_income: `${(yearIncome / 12).toFixed(2)} USD/month`,
+        education: random(['High School', "Bachelor's", "Master's", 'PhD']),
+        work_experience: `${randomNumber(0, 20)} years`,
+        health_status: random(['Healthy', 'Minor Issues', 'Chronic Conditions']),
+        emergency_contacts: emergencyContacts,
+        subscriptions,
+        pets,
+    };
+}

package/src/modules/v4/qrcode.ts

@@ -0,0 +1,11 @@
+import { toDataURL } from 'qrcode';
+
+export default async function qrcode(url: string): Promise<string> {
+    if (!url || typeof url !== 'string') throw new Error('Please provide a valid URL');
+
+    try {
+        return await toDataURL(url);
+    } catch (error) {
+        throw new Error(`Failed to generate QR code: ${(error as Error).message}`);
+    }
+}

package/src/modules/v4/tic_tac_toe.ts

@@ -0,0 +1,223 @@
+import { randomBytes } from 'crypto';
+import { SESSION_TTL, GAME_CLEANUP_TTL, RATE_LIMIT_WINDOW, RATE_LIMIT_MAX } from '../../constants.js';
+import type { TicTacToeStorage, TicTacToeMove, TicTacToeGame } from '../../types/storage.js';
+
+interface TicTacToeParams {
+    username?: string;
+    move?: string;
+    session?: string;
+    game?: string;
+    private?: boolean;
+    storage: TicTacToeStorage;
+}
+
+interface GameResult {
+    winner?: string | null;
+    loser?: string | null;
+    tie?: boolean;
+}
+
+export default function tic_tac_toe(action: string, params: TicTacToeParams): Record<string, unknown> {
+    const storage = params.storage;
+
+    storage.games ??= {};
+    storage.sessions ??= {};
+    storage.rateLimits ??= {};
+
+    const { games, sessions, rateLimits } = storage;
+
+    if (action === 'list') return listGames(games);
+
+    if (!params.username) throw new Error('Please provide a username');
+
+    const u = params.username.toLowerCase();
+    const now = Date.now();
+
+    rateLimits[u] = (rateLimits[u] ?? []).filter((ts) => now - ts < RATE_LIMIT_WINDOW);
+    if (rateLimits[u]!.length > RATE_LIMIT_MAX) {
+        const remainingTime = Math.ceil((rateLimits[u]![0]! + RATE_LIMIT_WINDOW - now) / 1000);
+        throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
+    }
+    rateLimits[u]!.push(now);
+
+    if (action === 'play') {
+        return playMove(params, games, sessions, u, now);
+    } else if (action === 'fetch') {
+        return fetchGame(params, games, u);
+    } else {
+        throw new Error('Invalid action. Use "play", "fetch", or "list"');
+    }
+}
+
+function playMove(
+    params: TicTacToeParams,
+    games: Record<string, TicTacToeGame>,
+    sessions: Record<string, { user: string; last: number }>,
+    u: string,
+    now: number,
+): Record<string, unknown> {
+    const { move, session, game } = params;
+    const validMoves = ['1-1', '1-2', '1-3', '2-1', '2-2', '2-3', '3-1', '3-2', '3-3'];
+
+    if (!move) throw new Error('Please provide a valid move');
+    if (!session) throw new Error('Please provide a valid session ID');
+    if (!game) throw new Error('Please provide a valid game ID');
+    if (!validMoves.includes(move)) throw new Error('Invalid move. Please provide a valid move (e.g., 1-1, 2-2, 3-3).');
+
+    if (sessions[u] && sessions[u].user !== session) {
+        throw new Error('Session ID mismatch');
+    }
+
+    games[game] = games[game] ?? {
+        moves: [],
+        players: [],
+        private: params.private || false,
+        creation: Date.now(),
+    };
+    const moves = games[game]!.moves;
+
+    const players = [...new Set(moves.map((play) => play.username))];
+    if (players.length >= 2 && !players.includes(params.username!)) {
+        throw new Error('Game is full, you can only watch.');
+    }
+
+    if (moves.length > 0 && moves[moves.length - 1]!.username === params.username) {
+        throw new Error('Please wait for the other player to make a move.');
+    }
+
+    if (moves.some((play) => play.move === move)) {
+        throw new Error('Move already made. Please choose a different move.');
+    }
+
+    const play: TicTacToeMove = { username: params.username!, move, session };
+    moves.push(play);
+
+    const result = checkGame(moves);
+    if (result.winner || result.tie) {
+        setTimeout(() => delete games[game!], GAME_CLEANUP_TTL);
+        return {
+            message: `Move sent successfully. ${result.winner ? result.winner + ' wins. ' + result.loser + ' loses.' : "It's a tie."}`,
+            ...result,
+        };
+    }
+
+    setTimeout(() => delete games[game!], SESSION_TTL);
+
+    sessions[u] = sessions[u] ?? { user: session, last: now };
+    sessions[u]!.last = now;
+    setTimeout(() => {
+        if (sessions[u] && now - sessions[u].last >= SESSION_TTL) delete sessions[u];
+    }, SESSION_TTL);
+
+    return { message: 'Move sent successfully' };
+}
+
+function fetchGame(params: TicTacToeParams, games: Record<string, TicTacToeGame>, u: string): Record<string, unknown> {
+    const id = params.game || generateGameId();
+    if (!games[id]) {
+        games[id] = {
+            moves: [],
+            players: [],
+            private: params.private || false,
+            creation: Date.now(),
+        };
+    }
+    if (!games[id]!.players.includes(u)) {
+        games[id]!.players.push(u);
+    }
+
+    const moves = games[id]!.moves;
+    const players = games[id]!.players;
+    const privateGame = games[id]!.private;
+    const lastPlayer = moves.length ? moves[moves.length - 1]!.username : null;
+    const turn = players.find((p) => p !== lastPlayer) || players[0];
+    const status = players.length >= 2 ? 'ready' : 'waiting';
+    const result = moves.length ? checkGame(moves) : {};
+
+    return {
+        id,
+        moves,
+        players,
+        turn,
+        status,
+        private: privateGame,
+        ...result,
+    };
+}
+
+function listGames(games: Record<string, TicTacToeGame>): Record<string, unknown> {
+    const publicGames: Record<string, unknown>[] = [];
+    const now = Date.now();
+
+    for (const [gameId, game] of Object.entries(games)) {
+        if (!game.private) {
+            const result = game.moves.length ? checkGame(game.moves) : {};
+            const isFinished = result.winner || result.tie;
+
+            if (!isFinished) {
+                const lastPlayer = game.moves.length ? game.moves[game.moves.length - 1]!.username : null;
+                const turn = game.players.find((p) => p !== lastPlayer) || game.players[0];
+                const status = game.players.length >= 2 ? 'ready' : 'waiting';
+
+                publicGames.push({
+                    id: gameId,
+                    players: game.players,
+                    playersCount: game.players.length,
+                    moves: game.moves.length,
+                    turn,
+                    status,
+                    creation: game.creation || now,
+                });
+            }
+        }
+    }
+
+    publicGames.sort((a, b) => (b.creation as number) - (a.creation as number));
+
+    return {
+        message: 'Public games available',
+        count: publicGames.length,
+        games: publicGames,
+    };
+}
+
+function generateGameId(): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    return Array.from(randomBytes(5))
+        .map((b) => chars[b % chars.length])
+        .join('');
+}
+
+function checkGame(moves: TicTacToeMove[]): GameResult {
+    const board: (string | null)[][] = Array(3)
+        .fill(null)
+        .map(() => Array(3).fill(null) as (string | null)[]);
+    const playerSymbols: Record<string, string> = {};
+    const playersOrder: string[] = [];
+
+    moves.forEach(({ username, move }) => {
+        if (!playerSymbols[username]) {
+            playersOrder.push(username);
+            playerSymbols[username] = playersOrder.length === 1 ? 'X' : 'O';
+        }
+        const [row, col] = move.split('-').map(Number) as [number, number];
+        board[row - 1]![col - 1] = playerSymbols[username]!;
+    });
+
+    const checkWinner = (symbol: string): boolean => {
+        for (let i = 0; i < 3; i++) {
+            if (board[i]![0] === symbol && board[i]![1] === symbol && board[i]![2] === symbol) return true;
+            if (board[0]![i] === symbol && board[1]![i] === symbol && board[2]![i] === symbol) return true;
+        }
+        if (board[0]![0] === symbol && board[1]![1] === symbol && board[2]![2] === symbol) return true;
+        if (board[0]![2] === symbol && board[1]![1] === symbol && board[2]![0] === symbol) return true;
+        return false;
+    };
+
+    const winner = Object.keys(playerSymbols).find((player) => checkWinner(playerSymbols[player]!)) ?? null;
+    const isTie = !winner && moves.length === 9;
+    const loser =
+        winner && playersOrder.length === 2 ? (playersOrder.find((player) => player !== winner) ?? null) : null;
+
+    return { winner, loser, tie: isTie };
+}

package/src/modules/v4/time.ts

@@ -0,0 +1,92 @@
+const validFormats = [
+    'iso',
+    'utc',
+    'timestamp',
+    'locale',
+    'date',
+    'time',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'ms',
+    'dayOfWeek',
+    'dayOfYear',
+    'weekNumber',
+    'timezone',
+    'timezoneOffset',
+] as const;
+
+const validTimezones = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'] as const;
+
+type TimeFormat = (typeof validFormats)[number];
+type Timezone = (typeof validTimezones)[number];
+
+export default function time(
+    type: string = 'live',
+    start?: string,
+    end?: string,
+    format?: string,
+    timezone?: string,
+): Record<string, unknown> {
+    if (type !== 'live' && type !== 'random') {
+        throw new Error('Please provide a valid type (live or random)');
+    }
+
+    if (start && !Date.parse(start)) {
+        throw new Error('Please provide a valid start date (YYYY-MM-DD)');
+    }
+
+    if (end && !Date.parse(end)) {
+        throw new Error('Please provide a valid end date (YYYY-MM-DD)');
+    }
+
+    if (format && !validFormats.includes(format as TimeFormat)) {
+        throw new Error(`Please provide a valid format. Options: ${validFormats.join(', ')}`);
+    }
+
+    if (timezone && !validTimezones.includes(timezone as Timezone)) {
+        throw new Error(`Please provide a valid timezone. Options: ${validTimezones.join(', ')}`);
+    }
+
+    const getTimeFormats = (date: Date, tz: string): Record<string, unknown> => {
+        return {
+            iso: date.toISOString(),
+            utc: date.toUTCString(),
+            timestamp: date.getTime(),
+            locale: date.toLocaleString('en-US', { timeZone: tz, timeZoneName: 'long' }),
+            date: date.toLocaleDateString('en-US', { timeZone: tz }),
+            time: date.toLocaleTimeString('en-US', { timeZone: tz }),
+            year: date.getFullYear(),
+            month: date.getMonth() + 1,
+            day: date.getDate(),
+            hour: date.getHours(),
+            minute: date.getMinutes(),
+            second: date.getSeconds(),
+            ms: date.getMilliseconds(),
+            dayOfWeek: date.getDay(),
+            dayOfYear: Math.floor((date.getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000),
+            weekNumber: Math.ceil(((date.getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000 + 1) / 7),
+            timezone: tz,
+            timezoneOffset: date.getTimezoneOffset(),
+        };
+    };
+
+    if (type === 'random') {
+        const startDate = start ? new Date(start).getTime() : new Date('1900-01-01').getTime();
+        const endDate = end ? new Date(end).getTime() : new Date('2100-12-31').getTime();
+        const randomDate = new Date(startDate + Math.random() * (endDate - startDate));
+        const tz = timezone || validTimezones[Math.floor(Math.random() * validTimezones.length)]!;
+        const formats = getTimeFormats(randomDate, tz);
+
+        return format ? { date: formats[format] } : formats;
+    }
+
+    const now = new Date();
+    const tz = timezone || 'UTC';
+    const formats = getTimeFormats(now, tz);
+
+    return format ? { date: formats[format] } : formats;
+}