@20syldev/api 4.7.0 → 4.9.0

package/src/modules/v4/text.ts

@@ -1,330 +0,0 @@
-import { MAX_STRING_LENGTH } from '../../constants.js';
-
-const LOREM_WORDS = [
-    'lorem',
-    'ipsum',
-    'dolor',
-    'sit',
-    'amet',
-    'consectetur',
-    'adipiscing',
-    'elit',
-    'sed',
-    'do',
-    'eiusmod',
-    'tempor',
-    'incididunt',
-    'ut',
-    'labore',
-    'et',
-    'dolore',
-    'magna',
-    'aliqua',
-    'enim',
-    'ad',
-    'minim',
-    'veniam',
-    'quis',
-    'nostrud',
-    'exercitation',
-    'ullamco',
-    'laboris',
-    'nisi',
-    'aliquip',
-    'ex',
-    'ea',
-    'commodo',
-    'consequat',
-    'duis',
-    'aute',
-    'irure',
-    'in',
-    'reprehenderit',
-    'voluptate',
-    'velit',
-    'esse',
-    'cillum',
-    'eu',
-    'fugiat',
-    'nulla',
-    'pariatur',
-    'excepteur',
-    'sint',
-    'occaecat',
-    'cupidatat',
-    'non',
-    'proident',
-    'sunt',
-    'culpa',
-    'qui',
-    'officia',
-    'deserunt',
-    'mollit',
-    'anim',
-    'id',
-    'est',
-    'laborum',
-];
-
-const FR_UNITS = [
-    'zéro',
-    'un',
-    'deux',
-    'trois',
-    'quatre',
-    'cinq',
-    'six',
-    'sept',
-    'huit',
-    'neuf',
-    'dix',
-    'onze',
-    'douze',
-    'treize',
-    'quatorze',
-    'quinze',
-    'seize',
-    'dix-sept',
-    'dix-huit',
-    'dix-neuf',
-];
-const FR_TENS = [
-    '',
-    '',
-    'vingt',
-    'trente',
-    'quarante',
-    'cinquante',
-    'soixante',
-    'soixante',
-    'quatre-vingt',
-    'quatre-vingt',
-];
-
-const EN_UNITS = [
-    'zero',
-    'one',
-    'two',
-    'three',
-    'four',
-    'five',
-    'six',
-    'seven',
-    'eight',
-    'nine',
-    'ten',
-    'eleven',
-    'twelve',
-    'thirteen',
-    'fourteen',
-    'fifteen',
-    'sixteen',
-    'seventeen',
-    'eighteen',
-    'nineteen',
-];
-const EN_TENS = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
-
-function checkText(value: string): void {
-    if (!value) throw new Error('A value is required');
-    if (typeof value !== 'string') throw new Error('Value must be a string');
-    if (value.length > MAX_STRING_LENGTH)
-        throw new Error(`Value must be less than ${MAX_STRING_LENGTH} characters long`);
-}
-
-export interface TextStats {
-    characters: number;
-    charactersNoSpaces: number;
-    words: number;
-    sentences: number;
-    paragraphs: number;
-    readingTime: string;
-    mostFrequentChar: string;
-}
-
-/**
- * Analyzes a text string and returns character, word, sentence, and reading time statistics.
- *
- * @param value - The text to analyze
- * @returns Object containing character counts, word/sentence/paragraph counts, reading time, and most frequent character
- * @throws Error if value is missing, not a string, or too long
- */
-export function stats(value: string): TextStats {
-    checkText(value);
-
-    const characters = value.length;
-    const charactersNoSpaces = value.replace(/\s/g, '').length;
-    const words = value.trim().split(/\s+/).filter(Boolean).length;
-    const sentences = value.split(/[.!?]+/).filter((s) => s.trim().length > 0).length;
-    const paragraphs = value.split(/\n\s*\n/).filter((p) => p.trim().length > 0).length || 1;
-
-    const minutes = words / 200;
-    const readingTime = minutes < 1 ? `${Math.ceil(minutes * 60)}s` : `${Math.round(minutes)}min`;
-
-    const counts = new Map<string, number>();
-    for (const c of value.replace(/\s/g, '').toLowerCase()) counts.set(c, (counts.get(c) ?? 0) + 1);
-    let mostFrequentChar = '';
-    let maxCount = 0;
-    for (const [char, count] of counts) {
-        if (count > maxCount) {
-            mostFrequentChar = char;
-            maxCount = count;
-        }
-    }
-
-    return { characters, charactersNoSpaces, words, sentences, paragraphs, readingTime, mostFrequentChar };
-}
-
-/**
- * Converts a string to a URL-friendly slug.
- *
- * @param value - The string to slugify
- * @returns Lowercase hyphenated slug with diacritics and special characters removed
- * @throws Error if value is missing, not a string, or too long
- */
-export function slug(value: string): string {
-    checkText(value);
-    return value
-        .normalize('NFD')
-        .replace(/[\u0300-\u036f]/g, '')
-        .toLowerCase()
-        .replace(/[^a-z0-9\s-]/g, '')
-        .trim()
-        .replace(/[\s-]+/g, '-');
-}
-
-/**
- * Generates Lorem Ipsum placeholder text.
- *
- * @param type - Content type: "words", "sentences", or "paragraphs"
- * @param count - Number of words, sentences, or paragraphs to generate
- * @returns Generated Lorem Ipsum text
- * @throws Error if count is out of range or type is not one of the accepted values
- */
-export function lorem(type: string, count: string): string {
-    const n = Number(count) || 5;
-    if (n < 1 || n > 500) throw new Error('Count must be between 1 and 500');
-
-    const randomWord = (): string => LOREM_WORDS[Math.floor(Math.random() * LOREM_WORDS.length)]!;
-    const randomSentence = (): string => {
-        const length = 5 + Math.floor(Math.random() * 10);
-        const words = Array.from({ length }, randomWord);
-        words[0] = words[0]!.charAt(0).toUpperCase() + words[0]!.slice(1);
-        return words.join(' ') + '.';
-    };
-    const randomParagraph = (): string => {
-        const length = 3 + Math.floor(Math.random() * 5);
-        return Array.from({ length }, randomSentence).join(' ');
-    };
-
-    switch (type) {
-        case 'words':
-            return Array.from({ length: n }, randomWord).join(' ');
-        case 'sentences':
-            return Array.from({ length: n }, randomSentence).join(' ');
-        case 'paragraphs':
-            return Array.from({ length: n }, randomParagraph).join('\n\n');
-        default:
-            throw new Error('Type must be one of: words, sentences, paragraphs');
-    }
-}
-
-function frBelowHundred(n: number): string {
-    if (n < 20) return FR_UNITS[n]!;
-    const t = Math.floor(n / 10);
-    const u = n % 10;
-    if (t === 7 || t === 9) {
-        const base = FR_TENS[t]!;
-        const sub = 10 + u;
-        return base + (base.endsWith('-') ? '' : '-') + FR_UNITS[sub];
-    }
-    if (t === 8 && u === 0) return 'quatre-vingts';
-    if (u === 0) return FR_TENS[t]!;
-    if (u === 1 && t < 8) return FR_TENS[t] + ' et un';
-    return FR_TENS[t] + '-' + FR_UNITS[u];
-}
-
-function frBelowThousand(n: number): string {
-    if (n < 100) return frBelowHundred(n);
-    const h = Math.floor(n / 100);
-    const r = n % 100;
-    let result = '';
-    if (h === 1) result = 'cent';
-    else result = FR_UNITS[h] + ' cent' + (r === 0 ? 's' : '');
-    if (r > 0) result += ' ' + frBelowHundred(r);
-    return result;
-}
-
-function numberToFrench(n: number): string {
-    if (n === 0) return 'zéro';
-    if (n < 0) return 'moins ' + numberToFrench(-n);
-    if (n < 1000) return frBelowThousand(n);
-    if (n < 1_000_000) {
-        const t = Math.floor(n / 1000);
-        const r = n % 1000;
-        const thousands = t === 1 ? 'mille' : frBelowThousand(t) + ' mille';
-        return r === 0 ? thousands : thousands + ' ' + frBelowThousand(r);
-    }
-    if (n < 1_000_000_000) {
-        const m = Math.floor(n / 1_000_000);
-        const r = n % 1_000_000;
-        const millions = m === 1 ? 'un million' : frBelowThousand(m) + ' millions';
-        return r === 0 ? millions : millions + ' ' + numberToFrench(r);
-    }
-    throw new Error('Number must be less than 1 billion');
-}
-
-function enBelowHundred(n: number): string {
-    if (n < 20) return EN_UNITS[n]!;
-    const t = Math.floor(n / 10);
-    const u = n % 10;
-    return u === 0 ? EN_TENS[t]! : EN_TENS[t] + '-' + EN_UNITS[u];
-}
-
-function enBelowThousand(n: number): string {
-    if (n < 100) return enBelowHundred(n);
-    const h = Math.floor(n / 100);
-    const r = n % 100;
-    return r === 0 ? EN_UNITS[h] + ' hundred' : EN_UNITS[h] + ' hundred ' + enBelowHundred(r);
-}
-
-function numberToEnglish(n: number): string {
-    if (n === 0) return 'zero';
-    if (n < 0) return 'minus ' + numberToEnglish(-n);
-    if (n < 1000) return enBelowThousand(n);
-    if (n < 1_000_000) {
-        const t = Math.floor(n / 1000);
-        const r = n % 1000;
-        return r === 0 ? enBelowThousand(t) + ' thousand' : enBelowThousand(t) + ' thousand ' + enBelowThousand(r);
-    }
-    if (n < 1_000_000_000) {
-        const m = Math.floor(n / 1_000_000);
-        const r = n % 1_000_000;
-        return r === 0 ? enBelowThousand(m) + ' million' : enBelowThousand(m) + ' million ' + numberToEnglish(r);
-    }
-    throw new Error('Number must be less than 1 billion');
-}
-
-/**
- * Converts an integer to its written-out word form in French or English.
- *
- * @param value - The integer to convert (must be less than 1 billion)
- * @param lang - Language: "fr" for French or "en" for English
- * @returns The number written out in words
- * @throws Error if value is not an integer, exceeds the maximum, or lang is not supported
- */
-export function number(value: string, lang: string): string {
-    const n = Number(value);
-    if (isNaN(n)) throw new Error('Value must be a number');
-    if (!Number.isInteger(n)) throw new Error('Value must be an integer');
-    if (Math.abs(n) >= 1_000_000_000) throw new Error('Number must be less than 1 billion');
-
-    switch (lang) {
-        case 'fr':
-            return numberToFrench(n);
-        case 'en':
-            return numberToEnglish(n);
-        default:
-            throw new Error('Lang must be one of: fr, en');
-    }
-}

package/src/modules/v4/tic_tac_toe.ts

@@ -1,264 +0,0 @@
-import { randomBytes } from 'crypto';
-
-import { GAME_CLEANUP_TTL, RATE_LIMIT_MAX, RATE_LIMIT_WINDOW, SESSION_TTL } from '../../constants.js';
-import type { TicTacToeGame, TicTacToeMove, TicTacToeStorage } 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;
-}
-
-/**
- * Handles Tic-Tac-Toe game actions including playing a move, fetching game state, listing games, and forfeiting.
- *
- * @param action - The action to perform: "play", "fetch", "list", or "forfeit"
- * @param params - Game parameters including username, move, session, game ID, and shared storage
- * @returns Game state or action result depending on the action
- * @throws Error if a required parameter is missing, the action is invalid, or a rate limit is exceeded
- */
-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 if (action === 'forfeit') {
-        return forfeitGame(params, games, sessions);
-    } else {
-        throw new Error('Invalid action. Use "play", "fetch", "list", or "forfeit"');
-    }
-}
-
-function forfeitGame(
-    params: TicTacToeParams,
-    games: Record<string, TicTacToeGame>,
-    sessions: Record<string, { user: string; last: number }>,
-): Record<string, unknown> {
-    const { game, session } = params;
-
-    if (!game) throw new Error('Please provide a valid game ID');
-    if (!session) throw new Error('Please provide a valid session ID');
-    if (!games[game]) throw new Error('Game not found');
-
-    const u = params.username!.toLowerCase();
-    if (sessions[u] && sessions[u].user !== session) {
-        throw new Error('Session ID mismatch');
-    }
-
-    const players = games[game]!.players;
-    if (!players.includes(u)) throw new Error('You are not a player in this game');
-
-    const winner = players.find((p) => p !== u) ?? null;
-    delete games[game];
-    delete sessions[u];
-
-    return {
-        message: `${params.username} forfeited the game.${winner ? ` ${winner} wins.` : ''}`,
-        winner,
-        loser: params.username,
-    };
-}
-
-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

@@ -1,103 +0,0 @@
-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];
-
-/**
- * Returns the current or a random date/time in various formats and timezones.
- *
- * @param type - "live" for the current time or "random" for a random date within a range
- * @param start - Optional start date for random mode (YYYY-MM-DD)
- * @param end - Optional end date for random mode (YYYY-MM-DD)
- * @param format - Optional specific format to return (e.g. "iso", "timestamp", "year")
- * @param timezone - Optional timezone (e.g. "UTC", "Europe/Paris")
- * @returns Object containing all time formats, or a single format if specified
- * @throws Error if type, format, or timezone is invalid
- */
-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;
-}