@20syldev/api 4.7.0 → 4.9.0

package/src/modules/v3/personal.js

@@ -1,139 +0,0 @@
-import { random, randomNumber } from './utils.js';
-
-/**
- * Generate random personal information
- *
- * @returns {Object} Comprehensive personal profile with contact info, financial data, and more
- */
-export default function personal() {
-    const people = [
-        { 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 = {
-        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 phone = countries[country].tel;
-    const lang = countries[country].lang;
-
-    const age = randomNumber(18, 67);
-    const birthday = new Date(Date.now() - randomNumber(18, 67) * 365.25 * 24 * 60 * 60 * 1000).toISOString();
-
-    let emergencyContacts = [];
-    let yearIncome = randomNumber(20000, 100000);
-    let subscriptions = [];
-    let pets = [];
-    let vehicles = [];
-    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.email === emergencyContact.email)
-        ) {
-            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: `+${countries[country].code} ${emergencyPhone}`,
-        });
-    }
-
-    while (subscriptions.length < randomNumber(1, 3)) {
-        let subscription = random(['Netflix', 'Spotify', 'Amazon Prime', 'Disney+', 'Hulu']);
-        if (!subscriptions.includes(subscription)) subscriptions.push(subscription);
-    }
-
-    while (pets.length < randomNumber(1, 3)) {
-        let pet = random(['Dog', 'Cat', 'Fish', 'Bird', 'None']);
-        if (!pets.includes(pet)) pets.push(pet);
-    }
-
-    while (vehicles.length < randomNumber(1, 3)) {
-        let vehicle = random(['Car', 'Bike', 'Motorcycle', 'Bus', 'None']);
-        if (!vehicles.includes(vehicle)) vehicles.push(vehicle);
-    }
-
-    return {
-        name: person.name,
-        email: person.email,
-        localisation: country,
-        phone: `+${countries[country].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/v3/qrcode.js

@@ -1,20 +0,0 @@
-import { toDataURL } from 'qrcode';
-
-/**
- * Generate a QR code for the provided URL.
- *
- * @param {string} url - The URL to encode in the QR code
- * @returns {Promise<string>} - Base64 encoded QR code image
- * @throws {Error} - If URL is invalid or QR code generation fails
- */
-export default async function qrcode(url) {
-    // Input validation
-    if (!url || typeof url !== 'string') throw new Error('Please provide a valid URL');
-
-    try {
-        // Generate QR code
-        return await toDataURL(url);
-    } catch (error) {
-        throw new Error(`Failed to generate QR code: ${error.message}`);
-    }
-}

package/src/modules/v3/tic_tac_toe.js

@@ -1,242 +0,0 @@
-import { randomBytes } from 'crypto';
-
-/**
- * Manages a Tic-Tac-Toe game session
- *
- * @param {string} action - The action to perform ('play', 'fetch', or 'list')
- * @param {Object} params - The parameters for the action
- * @returns {Object} - The result of the action
- * @throws {Error} - If parameters are invalid
- */
-export default function tic_tac_toe(action, params = {}) {
-    // In-memory storage
-    const storage = params.storage || {};
-
-    // Initialize storage
-    storage.games ??= {};
-    storage.sessions ??= {};
-    storage.rateLimits ??= {};
-
-    // Reference the storage properties
-    const { games, sessions, rateLimits } = storage;
-
-    // List public games
-    if (action === 'list') return listGames(games);
-
-    // Input validation for common parameters
-    if (!params.username) throw new Error('Please provide a username');
-
-    const u = params.username.toLowerCase();
-    const now = Date.now();
-
-    // Rate limiting
-    rateLimits[u] = (rateLimits[u] || []).filter((ts) => now - ts < 10000);
-    if (rateLimits[u].length > 50) {
-        const remainingTime = Math.ceil((rateLimits[u][0] + 10000 - now) / 1000);
-        throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
-    }
-    rateLimits[u].push(now);
-
-    // Handle different actions
-    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"');
-    }
-}
-
-/**
- * Process a player's move
- */
-function playMove(params, games, sessions, u, now) {
-    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'];
-
-    // Input validation for play action
-    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).');
-
-    // Session validation
-    if (sessions[u] && sessions[u].user !== session) {
-        throw new Error('Session ID mismatch');
-    }
-
-    // Initialize game if needed
-    games[game] = games[game] || {
-        moves: [],
-        players: [],
-        private: params.private || false,
-        creation: Date.now(),
-    };
-    const moves = games[game].moves;
-
-    // Check if game is full
-    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.');
-    }
-
-    // Check if it's player's turn
-    if (moves.length > 0 && moves[moves.length - 1].username === params.username) {
-        throw new Error('Please wait for the other player to make a move.');
-    }
-
-    // Check if move is already made
-    if (moves.some((play) => play.move === move)) {
-        throw new Error('Move already made. Please choose a different move.');
-    }
-
-    // Add move to game
-    const play = { username: params.username, move, session };
-    moves.push(play);
-
-    // Check game result
-    const result = checkGame(moves);
-    if (result.winner || result.tie) {
-        setTimeout(() => delete games[game], 600000);
-        return {
-            message: `Move sent successfully. ${result.winner ? result.winner + ' wins. ' + result.loser + ' loses.' : "It's a tie."}`,
-            ...result,
-        };
-    }
-
-    // Set cleanup timeout
-    setTimeout(() => delete games[game], 3600000);
-
-    // Update session
-    sessions[u] = sessions[u] || { user: session, last: now };
-    sessions[u].last = now;
-    setTimeout(() => {
-        if (now - sessions[u].last >= 3600000) delete sessions[u];
-    }, 3600000);
-
-    return { message: 'Move sent successfully' };
-}
-
-/**
- * Fetch a game state
- */
-function fetchGame(params, games, u) {
-    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,
-    };
-}
-
-/**
- * List all public games in progress
- */
-function listGames(games) {
-    const publicGames = [];
-    const now = Date.now();
-
-    for (const [gameId, game] of Object.entries(games)) {
-        // Only include public games
-        if (!game.private) {
-            const result = game.moves.length ? checkGame(game.moves) : {};
-            const isFinished = result.winner || result.tie;
-
-            // Only include active games (not finished)
-            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,
-                });
-            }
-        }
-    }
-
-    // Sort by creation time (newest first)
-    publicGames.sort((a, b) => b.creation - a.creation);
-
-    return {
-        message: 'Public games available',
-        count: publicGames.length,
-        games: publicGames,
-    };
-}
-
-/**
- * Generate a random game ID
- */
-function generateGameId() {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-    return Array.from(randomBytes(5))
-        .map((b) => chars[b % chars.length])
-        .join('');
-}
-
-/**
- * Check the game result
- */
-function checkGame(moves) {
-    let board = Array(3)
-        .fill()
-        .map(() => Array(3).fill(null));
-    let playerSymbols = {};
-    let playersOrder = [];
-
-    moves.forEach(({ username, move }) => {
-        if (!playerSymbols[username]) {
-            playersOrder.push(username);
-            playerSymbols[username] = playersOrder.length === 1 ? 'X' : 'O';
-        }
-        let [row, col] = move.split('-').map(Number);
-        board[row - 1][col - 1] = playerSymbols[username];
-    });
-
-    const checkWinner = (symbol) => {
-        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;
-    };
-
-    let winner = Object.keys(playerSymbols).find((player) => checkWinner(playerSymbols[player]));
-    let isTie = !winner && moves.length === 9;
-    let loser = winner && playersOrder.length === 2 ? playersOrder.find((player) => player !== winner) : null;
-
-    return { winner, loser, tie: isTie };
-}

package/src/modules/v3/time.js

@@ -1,98 +0,0 @@
-/**
- * Generate time information based on specified parameters.
- *
- * @param {string} type - The type of time information ('live' or 'random')
- * @param {string} start - Start date for random generation (ISO format)
- * @param {string} end - End date for random generation (ISO format)
- * @param {string} format - Specific time format to return
- * @param {string} timezone - Timezone to use
- * @returns {object} - Time information in various formats
- * @throws {Error} - If inputs are invalid
- */
-export default function time(type = 'live', start, end, format, timezone) {
-    const validFormats = [
-        'iso',
-        'utc',
-        'timestamp',
-        'locale',
-        'date',
-        'time',
-        'year',
-        'month',
-        'day',
-        'hour',
-        'minute',
-        'second',
-        'ms',
-        'dayOfWeek',
-        'dayOfYear',
-        'weekNumber',
-        'timezone',
-        'timezoneOffset',
-    ];
-
-    const validTimezones = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'];
-
-    // Input validation
-    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)) {
-        throw new Error(`Please provide a valid format. Options: ${validFormats.join(', ')}`);
-    }
-
-    if (timezone && !validTimezones.includes(timezone)) {
-        throw new Error(`Please provide a valid timezone. Options: ${validTimezones.join(', ')}`);
-    }
-
-    // Helper function to get all time formats for a date
-    const getTimeFormats = (date, tz) => {
-        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 - new Date(date.getFullYear(), 0, 0)) / 86400000),
-            weekNumber: Math.ceil(((date - new Date(date.getFullYear(), 0, 0)) / 86400000 + 1) / 7),
-            timezone: tz,
-            timezoneOffset: date.getTimezoneOffset(),
-        };
-    };
-
-    // Generate time information based on type
-    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;
-    }
-
-    // Live time information
-    const now = new Date();
-    const tz = timezone || 'UTC';
-    const formats = getTimeFormats(now, tz);
-
-    return format ? { date: formats[format] } : formats;
-}

package/src/modules/v3/token.js

@@ -1,54 +0,0 @@
-import { randomBytes } from 'crypto';
-import { v4 } from 'uuid';
-
-/**
- * Generate a random token of specified length and type.
- *
- * @param {number} len - Length of the token
- * @param {string} type - Type of token to generate
- * @returns {string} - The generated token
- * @throws {Error} - If inputs are invalid
- */
-export default function token(len, type = 'alphanum') {
-    // Input validation
-    if (isNaN(len) || len < 12) {
-        throw new Error('Length must be a number greater than or equal to 12');
-    }
-
-    if (len > 4096) {
-        throw new Error('Length cannot exceed 4096');
-    }
-
-    // Helper function to generate token from character set
-    const genToken = (chars, length) => {
-        return Array.from({ length }, () => {
-            return chars[Math.floor(Math.random() * chars.length)];
-        }).join('');
-    };
-
-    // Token type definitions
-    const tokenTypes = {
-        alpha: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', len),
-        alphanum: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', len),
-        base64: () =>
-            randomBytes(Math.ceil(len * 0.75))
-                .toString('base64')
-                .slice(0, len),
-        hex: () =>
-            randomBytes(Math.ceil(len * 0.5))
-                .toString('hex')
-                .slice(0, len),
-        num: () => genToken('0123456789', len),
-        punct: () => genToken('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~', len),
-        urlsafe: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_', len),
-        uuid: () => v4().replace(/-/g, '').slice(0, len),
-    };
-
-    // Generate token based on type or default to alphanum
-    if (!tokenTypes[type.toLowerCase()]) {
-        throw new Error(`Invalid token type. Valid types: ${Object.keys(tokenTypes).join(', ')}`);
-    }
-
-    // Generate token based on type or default to alphanum
-    return (tokenTypes[type.toLowerCase()] || tokenTypes.alphanum)();
-}

package/src/modules/v3/username.js

@@ -1,94 +0,0 @@
-import { random, randomNumber } from './utils.js';
-
-/**
- * Generate a random username with related information
- *
- * @returns {Object} Object containing username and component parts
- */
-export default function username() {
-    const adj = [
-        'Happy',
-        'Silly',
-        'Clever',
-        'Creative',
-        'Brave',
-        'Gentle',
-        'Kind',
-        'Funny',
-        'Wise',
-        'Charming',
-        'Sincere',
-        'Resourceful',
-        'Patient',
-        'Energetic',
-        'Adventurous',
-        'Ambitious',
-        'Courageous',
-        'Courteous',
-        'Determined',
-    ];
-    const ani = [
-        'Cat',
-        'Dog',
-        'Tiger',
-        'Elephant',
-        'Monkey',
-        'Penguin',
-        'Dolphin',
-        'Lion',
-        'Bear',
-        'Fox',
-        'Owl',
-        'Giraffe',
-        'Zebra',
-        'Koala',
-        'Rabbit',
-        'Squirrel',
-        'Panda',
-        'Horse',
-        'Wolf',
-        'Eagle',
-    ];
-    const job = [
-        'Writer',
-        'Artist',
-        'Musician',
-        'Explorer',
-        'Scientist',
-        'Engineer',
-        'Athlete',
-        'Chef',
-        'Doctor',
-        'Teacher',
-        'Lawyer',
-        'Entrepreneur',
-        'Actor',
-        'Dancer',
-        'Photographer',
-        'Architect',
-        'Pilot',
-        'Designer',
-        'Journalist',
-        'Veterinarian',
-    ];
-
-    const nombre = randomNumber(0, 99);
-    const choix = {
-        adj_num: () => random(adj) + nombre,
-        ani_num: () => random(ani) + nombre,
-        pro_num: () => random(job) + nombre,
-        adj_ani: () => random(adj) + random(ani),
-        adj_ani_num: () => random(adj) + random(ani) + nombre,
-        adj_pro: () => random(adj) + random(job),
-        pro_ani: () => random(job) + random(ani),
-        pro_ani_num: () => random(job) + random(ani) + nombre,
-    };
-
-    return {
-        username: choix[random(Object.keys(choix))](),
-        number: nombre,
-        adjective: random(adj),
-        animal: random(ani),
-        job: random(job),
-    };
-}