@20syldev/api 4.8.0 → 4.9.0

package/src/modules/v4/time.ts

@@ -1,149 +0,0 @@
-import { MAX_COUNTDOWN_YEARS } from '../../constants.js';
-
-const VALID_FORMATS = [
-    'iso',
-    'utc',
-    'timestamp',
-    'locale',
-    'date',
-    'time',
-    'year',
-    'month',
-    'day',
-    'hour',
-    'minute',
-    'second',
-    'ms',
-    'dayOfWeek',
-    'dayOfYear',
-    'weekNumber',
-    'timezone',
-    'timezoneOffset',
-] as const;
-
-export const VALID_TIMEZONES = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'] as const;
-
-type TimeFormat = (typeof VALID_FORMATS)[number];
-type Timezone = (typeof VALID_TIMEZONES)[number];
-
-/**
- * Returns the current or a random date/time in various formats and timezones,
- * or computes a countdown/elapsed time to/from a target date.
- *
- * @param type - "live" for the current time, "random" for a random date, or "countdown" for a time diff
- * @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")
- * @param target - Required for countdown mode: target date in ISO 8601 or YYYY-MM-DD format
- * @returns Object containing all time formats, a single format, or a countdown result
- * @throws Error if type, format, timezone, or target is invalid
- */
-export default function time(
-    type: string = 'live',
-    start?: string,
-    end?: string,
-    format?: string,
-    timezone?: string,
-    target?: string,
-): Record<string, unknown> {
-    if (type !== 'live' && type !== 'random' && type !== 'countdown') {
-        throw new Error('Please provide a valid type (live, random or countdown)');
-    }
-
-    if (timezone && !VALID_TIMEZONES.includes(timezone as Timezone)) {
-        throw new Error(`Please provide a valid timezone. Options: ${VALID_TIMEZONES.join(', ')}`);
-    }
-
-    if (type === 'countdown') {
-        if (!target) {
-            throw new Error('Please provide a target date (?target=YYYY-MM-DD)');
-        }
-
-        const targetDate = new Date(target);
-        if (isNaN(targetDate.getTime())) {
-            throw new Error('Please provide a valid target date (ISO 8601 or YYYY-MM-DD)');
-        }
-
-        const now = new Date();
-        const maxMs = MAX_COUNTDOWN_YEARS * 365.25 * 24 * 3600 * 1000;
-
-        if (Math.abs(targetDate.getTime() - now.getTime()) > maxMs) {
-            throw new Error(`Target date must be within ${MAX_COUNTDOWN_YEARS} years from now`);
-        }
-
-        const direction: 'future' | 'past' = targetDate > now ? 'future' : 'past';
-        const diffMs = Math.abs(targetDate.getTime() - now.getTime());
-        const total_seconds = Math.floor(diffMs / 1000);
-
-        const days = Math.floor(total_seconds / 86400);
-        const hours = Math.floor((total_seconds % 86400) / 3600);
-        const minutes = Math.floor((total_seconds % 3600) / 60);
-        const seconds = total_seconds % 60;
-
-        const parts: string[] = [];
-        if (days > 0) parts.push(`${days} day${days !== 1 ? 's' : ''}`);
-        if (hours > 0) parts.push(`${hours} hour${hours !== 1 ? 's' : ''}`);
-        if (minutes > 0) parts.push(`${minutes} minute${minutes !== 1 ? 's' : ''}`);
-        if (seconds > 0) parts.push(`${seconds} second${seconds !== 1 ? 's' : ''}`);
-
-        return {
-            target: targetDate.toISOString(),
-            now: now.toISOString(),
-            direction,
-            remaining: { total_seconds, days, hours, minutes, seconds },
-            human: parts.length > 0 ? parts.join(', ') : '0 seconds',
-        };
-    }
-
-    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 && !VALID_FORMATS.includes(format as TimeFormat)) {
-        throw new Error(`Please provide a valid format. Options: ${VALID_FORMATS.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 || VALID_TIMEZONES[Math.floor(Math.random() * VALID_TIMEZONES.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;
-}

package/src/modules/v4/token.ts

@@ -1,53 +0,0 @@
-import { randomBytes, randomInt } from 'crypto';
-import { v4 } from 'uuid';
-
-import { MAX_TOKEN_LENGTH, MIN_TOKEN_LENGTH } from '../../constants.js';
-
-/**
- * Generates a cryptographically random token of the specified length and type.
- *
- * @param len - Token length (must be between 12 and 4096)
- * @param type - Character set to use: "alpha", "alphanum", "base64", "hex", "num", "punct", "urlsafe", or "uuid"
- * @returns The generated token string
- * @throws Error if length is out of range or the type is not valid
- */
-export default function token(len: number, type: string = 'alphanum'): string {
-    if (isNaN(len) || len < MIN_TOKEN_LENGTH) {
-        throw new Error('Length must be a number greater than or equal to 12');
-    }
-
-    if (len > MAX_TOKEN_LENGTH) {
-        throw new Error('Length cannot exceed 4096');
-    }
-
-    const genToken = (chars: string, length: number): string =>
-        Array.from({ length }, () => chars[randomInt(chars.length)]).join('');
-
-    const tokenTypes: Record<string, () => string> = {
-        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: () => {
-            let result = '';
-            while (result.length < len) result += v4().replace(/-/g, '');
-            return result.slice(0, len);
-        },
-    };
-
-    const lowerType = type.toLowerCase();
-    if (!tokenTypes[lowerType]) {
-        throw new Error(`Invalid token type. Valid types: ${Object.keys(tokenTypes).join(', ')}`);
-    }
-
-    return tokenTypes[lowerType]!();
-}

package/src/modules/v4/username.ts

@@ -1,94 +0,0 @@
-import { random, randomNumber } from '../../utils/helpers.js';
-
-/**
- * Generates a random username combining adjectives, animals, and job titles.
- *
- * @returns Object containing the generated username, the number used, and the components (adjective, animal, job)
- */
-export default function username(): Record<string, unknown> {
-    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: Record<string, () => string> = {
-        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),
-    };
-}

package/src/modules/v4/validate.ts

@@ -1,76 +0,0 @@
-import { MAX_STRING_LENGTH } from '../../constants.js';
-
-function checkValue(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`);
-}
-
-/**
- * Validates a credit/debit card number using the Luhn algorithm.
- *
- * @param value - Card number string (digits, spaces, or dashes allowed)
- * @returns Object containing the validity result and the sanitized digit string
- * @throws Error if value is missing, contains non-digit characters, or has an invalid length
- */
-export function luhn(value: string): { valid: boolean; value: string } {
-    checkValue(value);
-    const digits = value.replace(/\s|-/g, '');
-    if (!/^\d+$/.test(digits)) throw new Error('Value must contain only digits, spaces or dashes');
-    if (digits.length < 12 || digits.length > 19) throw new Error('Card number must have between 12 and 19 digits');
-
-    let sum = 0;
-    let alt = false;
-    for (let i = digits.length - 1; i >= 0; i--) {
-        let n = parseInt(digits[i]!, 10);
-        if (alt) {
-            n *= 2;
-            if (n > 9) n -= 9;
-        }
-        sum += n;
-        alt = !alt;
-    }
-
-    return { valid: sum % 10 === 0, value: digits };
-}
-
-/**
- * Validates an IBAN using the mod-97 checksum algorithm.
- *
- * @param value - IBAN string (spaces allowed)
- * @returns Object containing the validity result, sanitized IBAN, and country code
- * @throws Error if value is missing, has an invalid format, or is out of length bounds
- */
-export function iban(value: string): { valid: boolean; value: string; country?: string } {
-    checkValue(value);
-    const cleaned = value.replace(/\s/g, '').toUpperCase();
-    if (!/^[A-Z]{2}\d{2}[A-Z0-9]+$/.test(cleaned)) throw new Error('Invalid IBAN format');
-    if (cleaned.length < 15 || cleaned.length > 34) throw new Error('IBAN length must be between 15 and 34 characters');
-
-    const rearranged = cleaned.slice(4) + cleaned.slice(0, 4);
-    const numeric = rearranged
-        .split('')
-        .map((c) => (c >= 'A' && c <= 'Z' ? (c.charCodeAt(0) - 55).toString() : c))
-        .join('');
-
-    let remainder = 0;
-    for (const char of numeric) {
-        remainder = (remainder * 10 + parseInt(char, 10)) % 97;
-    }
-
-    return { valid: remainder === 1, value: cleaned, country: cleaned.slice(0, 2) };
-}
-
-/**
- * Validates an email address against a basic format check.
- *
- * @param value - The email address string to validate
- * @returns Object containing the validity result and the original value
- * @throws Error if value is missing, not a string, or too long
- */
-export function email(value: string): { valid: boolean; value: string } {
-    checkValue(value);
-    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return { valid: regex.test(value), value };
-}

package/src/modules/v4.ts

@@ -1,29 +0,0 @@
-export { default as address } from './v4/address.js';
-export { default as agent } from './v4/agent.js';
-export * as algorithms from './v4/algorithms.js';
-export { default as captcha } from './v4/captcha.js';
-export { default as chat } from './v4/chat.js';
-export { default as color } from './v4/color.js';
-export { default as convert } from './v4/convert.js';
-export { default as cron } from './v4/cron.js';
-export { default as dice } from './v4/dice.js';
-export { default as domain } from './v4/domain.js';
-export * as encode from './v4/encode.js';
-export { default as geo } from './v4/geo.js';
-export { default as hash } from './v4/hash.js';
-export { default as hyperplanning } from './v4/hyperplanning.js';
-export { default as ip } from './v4/ip.js';
-export { default as levenshtein } from './v4/levenshtein.js';
-export { default as palette } from './v4/palette.js';
-export { default as password } from './v4/password.js';
-export { default as personal } from './v4/personal.js';
-export { default as placeholder } from './v4/placeholder.js';
-export { default as qrcode } from './v4/qrcode.js';
-export { default as regex } from './v4/regex.js';
-export { default as statistics } from './v4/statistics.js';
-export * as text from './v4/text.js';
-export { default as tic_tac_toe } from './v4/tic_tac_toe.js';
-export { default as time } from './v4/time.js';
-export { default as token } from './v4/token.js';
-export { default as username } from './v4/username.js';
-export * as validate from './v4/validate.js';

package/src/routes/delete.ts

@@ -1,72 +0,0 @@
-import { type Request, type Response, Router } from 'express';
-
-import { chatStorage, ticTacToeStorage } from '../storage/index.js';
-import { error } from '../utils/response.js';
-
-const router = Router();
-
-// Clear a private chat
-router.delete('/:version/chat/:token', (req: Request, res: Response) => {
-    if (req.version !== 'v4') {
-        error(res, 405, 'DELETE is only supported in v4+.', `${req.version}/chat`);
-        return;
-    }
-
-    const token = req.params.token as string;
-    const { username, session } = (req.body as Record<string, string>) || {};
-
-    if (!username) {
-        error(res, 400, 'Please provide a username (?username={username})');
-        return;
-    }
-    if (!session) {
-        error(res, 400, 'Please provide a valid session ID (&session={ID})');
-        return;
-    }
-
-    try {
-        const result = req.module.chat('clear', {
-            username,
-            token,
-            session,
-            storage: chatStorage,
-        });
-        res.jsonResponse(result);
-    } catch (err) {
-        error(res, 400, (err as Error).message);
-    }
-});
-
-// Forfeit a tic-tac-toe game
-router.delete('/:version/tic-tac-toe/:game', (req: Request, res: Response) => {
-    if (req.version !== 'v4') {
-        error(res, 405, 'DELETE is only supported in v4+.', `${req.version}/tic-tac-toe`);
-        return;
-    }
-
-    const game = req.params.game as string;
-    const { username, session } = (req.body as Record<string, string>) || {};
-
-    if (!username) {
-        error(res, 400, 'Please provide a username (?username={username})');
-        return;
-    }
-    if (!session) {
-        error(res, 400, 'Please provide a valid session ID (&session={ID})');
-        return;
-    }
-
-    try {
-        const result = req.module.tic_tac_toe('forfeit', {
-            username,
-            session,
-            game,
-            storage: ticTacToeStorage,
-        });
-        res.jsonResponse(result);
-    } catch (err) {
-        error(res, 400, (err as Error).message);
-    }
-});
-
-export default router;