@20syldev/api 3.5.0 → 4.1.0

package/src/modules/v4/algorithms.ts

@@ -0,0 +1,197 @@
+import { MAX_FACTORIAL, MAX_GCD_VALUE, MAX_PRIME_LIST, MAX_STRING_LENGTH, ROMAN_VALUES } from '../../constants.js';
+
+export function anagram(value: string, value2: string): boolean {
+    if (!value) throw new Error('First value is required');
+    if (!value2) throw new Error('Second value is required');
+
+    if (typeof value !== 'string') throw new Error('First value must be a string');
+    if (typeof value2 !== 'string') throw new Error('Second value must be a string');
+
+    if (value.length < 2) throw new Error('First value must be at least two characters long');
+    if (value.length > MAX_STRING_LENGTH) throw new Error('First value must be less than 1000 characters long');
+
+    if (value2.length < 2) throw new Error('Second value must be at least two characters long');
+    if (value2.length > MAX_STRING_LENGTH) throw new Error('Second value must be less than 1000 characters long');
+
+    return value.split('').sort().join('') === value2.split('').sort().join('');
+}
+
+export function bubblesort(value: string): number[] {
+    if (!value) throw new Error('A value is required');
+
+    if (typeof value !== 'string') throw new Error('Value must be a string');
+
+    const arr = value.split(',').map(Number);
+
+    if (arr.some(isNaN)) throw new Error('Array must contain only numbers');
+    if (arr.length < 2) throw new Error('Array must contain at least two numbers');
+    if (arr.length > MAX_STRING_LENGTH) throw new Error('Array must contain less than 1000 numbers');
+
+    for (let i = 0; i < arr.length - 1; i++) {
+        for (let j = 0; j < arr.length - i - 1; j++) {
+            if (arr[j]! > arr[j + 1]!) [arr[j], arr[j + 1]] = [arr[j + 1]!, arr[j]!];
+        }
+    }
+
+    return arr;
+}
+
+export function factorial(value: string | number): number {
+    const num = Number(value);
+    if (isNaN(num)) throw new Error('Value must be a number');
+    if (num < 0) throw new Error('Number must be positive');
+    if (num > MAX_FACTORIAL) throw new Error('Number must be between 0 and 170');
+
+    return num <= 1 ? 1 : num * factorial(num - 1);
+}
+
+export function fibonacci(value: string | number): number[] {
+    const num = Number(value);
+    if (isNaN(num)) throw new Error('Value must be a number');
+    if (num < 0) throw new Error('Number must be positive');
+    if (num > 1000) throw new Error('Number must be between 0 and 1000');
+
+    const fib = [0, 1];
+
+    for (let i = 2; i < num; i++) {
+        fib.push(fib[i - 1]! + fib[i - 2]!);
+    }
+
+    return fib.slice(0, num);
+}
+
+export function gcd(value: string | number, value2: string | number): number {
+    let a = Number(value);
+    let b = Number(value2);
+    if (isNaN(a)) throw new Error('First value must be a number');
+    if (isNaN(b)) throw new Error('Second value must be a number');
+
+    if (a <= 0) throw new Error('First number must be strictly positive');
+    if (b <= 0) throw new Error('Second number must be strictly positive');
+
+    if (a > MAX_GCD_VALUE) throw new Error('First number must be between 0 and 100000');
+    if (b > MAX_GCD_VALUE) throw new Error('Second number must be between 0 and 100000');
+
+    a = Math.abs(a);
+    b = Math.abs(b);
+
+    while (b) [a, b] = [b, a % b];
+
+    return a;
+}
+
+export function isprime(value: string | number): boolean {
+    const num = Number(value);
+    if (isNaN(num)) throw new Error('Value must be a number');
+    if (num < 1) throw new Error('Number must be positive');
+    if (num > MAX_GCD_VALUE) throw new Error('Number must be between 1 and 100000');
+
+    for (let i = 2; i <= Math.sqrt(num); i++) {
+        if (num % i === 0) return false;
+    }
+
+    return true;
+}
+
+export function palindrome(value: string): boolean {
+    if (!value) throw new Error('A value is required');
+
+    if (typeof value !== 'string') throw new Error('Value must be a string');
+
+    if (value.length < 2) throw new Error('Value must be at least two characters long');
+    if (value.length > MAX_STRING_LENGTH) throw new Error('Value must be less than 1000 characters long');
+
+    return value === value.split('').reverse().join('');
+}
+
+export function primefactors(value: string | number): number[] {
+    let num = Number(value);
+    if (isNaN(num)) throw new Error('Value must be a number');
+    if (num < 2) throw new Error('Number must be positive and greater than 1');
+    if (num > MAX_GCD_VALUE) throw new Error('Number must be between 2 and 100000');
+
+    const factors: number[] = [];
+
+    for (let i = 2; i <= num; i++) {
+        while (num % i === 0) {
+            factors.push(i);
+            num /= i;
+        }
+    }
+
+    return factors;
+}
+
+export function primelist(value: string | number): number[] {
+    const num = Number(value);
+    if (isNaN(num)) throw new Error('Value must be a number');
+    if (num < 2) throw new Error('Number must be positive and greater than 1');
+    if (num > MAX_PRIME_LIST) throw new Error('Number must be between 2 and 10000');
+
+    const primes: number[] = [];
+
+    for (let i = 2; i <= num; i++) {
+        let isPrime = true;
+
+        for (let j = 2; j <= Math.sqrt(i); j++) {
+            if (i % j === 0) {
+                isPrime = false;
+                break;
+            }
+        }
+
+        if (isPrime) primes.push(i);
+    }
+
+    return primes;
+}
+
+export function reverse(value: string): string {
+    if (!value) throw new Error('A value is required');
+
+    if (typeof value !== 'string') throw new Error('Value must be a string');
+
+    return value.split('').reverse().join('');
+}
+
+export function roman(value: string): number | string {
+    if (!value) throw new Error('A value is required');
+
+    const num = Number(value);
+    if (!isNaN(num)) {
+        if (!Number.isInteger(num)) throw new Error('Value must be an integer');
+        if (num < 1 || num > 3999) throw new Error('Number must be between 1 and 3999');
+
+        let result = '';
+        let n = num;
+        for (const [val, sym] of ROMAN_VALUES) {
+            while (n >= val) {
+                result += sym;
+                n -= val;
+            }
+        }
+        return result;
+    }
+
+    if (typeof value !== 'string') throw new Error('Value must be a number or a Roman numeral');
+    const upper = value.toUpperCase();
+    if (!/^[MDCLXVI]+$/.test(upper)) throw new Error('Invalid Roman numeral');
+
+    let result = 0;
+    let i = 0;
+    while (i < upper.length) {
+        const two = upper.slice(i, i + 2);
+        const match = ROMAN_VALUES.find(([, sym]) => sym === two);
+        if (match) {
+            result += match[0];
+            i += 2;
+        } else {
+            const one = ROMAN_VALUES.find(([, sym]) => sym === upper[i]);
+            if (!one) throw new Error('Invalid Roman numeral');
+            result += one[0];
+            i += 1;
+        }
+    }
+
+    return result;
+}

package/src/modules/v4/captcha.ts

@@ -0,0 +1,49 @@
+import { createCanvas } from 'canvas';
+
+export default function captcha(text: string): Buffer {
+    if (!text) throw new Error('Text is required to generate a captcha.');
+
+    const size = 60,
+        font = '60px Comic Sans Ms',
+        width = text.length * size,
+        height = 120;
+    const canvas = createCanvas(width, height),
+        ctx = canvas.getContext('2d');
+
+    ctx.fillStyle = 'white';
+    ctx.fillRect(0, 0, width, height);
+
+    for (let i = 0; i < 20; i++) {
+        ctx.strokeStyle = 'rgba(0, 0, 0, 0.3)';
+        ctx.beginPath();
+        ctx.moveTo(Math.random() * width, Math.random() * height);
+        ctx.lineTo(Math.random() * width, Math.random() * height);
+        ctx.lineWidth = Math.random() * 2;
+        ctx.stroke();
+    }
+
+    let x = (canvas.width + 20 - width) / 2;
+
+    for (let i = 0; i < text.length; i++) {
+        const offsetX = Math.cos(i * 0.3) * 10,
+            y = height / 2.5 + Math.floor(Math.random() * (height / 2));
+
+        ctx.font = font;
+        ctx.fillStyle = `rgb(${Math.floor(Math.random() * 192)}, ${Math.floor(Math.random() * 192)}, ${Math.floor(Math.random() * 192)})`;
+
+        ctx.save();
+        ctx.translate(x + size / 2, y);
+        ctx.rotate((Math.random() - 0.5) * 0.5);
+        ctx.fillText(text[i]!, -size / 2 + offsetX, 0);
+        ctx.restore();
+
+        x += size;
+    }
+
+    for (let i = 0; i < 200; i++) {
+        ctx.fillStyle = 'black';
+        ctx.fillRect(Math.floor(Math.random() * width), Math.floor(Math.random() * height), 1.2, 1.2);
+    }
+
+    return canvas.toBuffer('image/png');
+}

package/src/modules/v4/chat.ts

@@ -0,0 +1,122 @@
+import { checkRateLimit } from './utils.js';
+import { SESSION_TTL } from '../../constants.js';
+import type { ChatStorage, ChatMessage } from '../../types/storage.js';
+
+interface ChatParams {
+    username: string;
+    message?: string;
+    timestamp?: string;
+    session?: string;
+    token?: string;
+    storage: ChatStorage;
+}
+
+export default function chat(action: string, params: ChatParams): ChatMessage[] | ChatMessage | { message: string } {
+    const storage = params.storage;
+
+    storage.messages ??= [];
+    storage.privateChats ??= {};
+    storage.sessions ??= {};
+    storage.rateLimits ??= {};
+
+    const { messages, privateChats, sessions, rateLimits } = storage;
+
+    if (!params.username) throw new Error('Please provide a username');
+
+    const u = params.username.toLowerCase();
+    const now = Date.now();
+
+    checkRateLimit(rateLimits, u, now);
+
+    if (action === 'message') {
+        return sendMessage(params, messages, privateChats, sessions, u, now);
+    } else if (action === 'private') {
+        return getPrivateChat(params, privateChats);
+    } else if (action === 'fetch') {
+        return fetchMessages(messages);
+    } else if (action === 'clear') {
+        return clearPrivateChat(params, privateChats, sessions, u);
+    } else {
+        throw new Error('Invalid action. Use "message", "private", "fetch", or "clear"');
+    }
+}
+
+function sendMessage(
+    params: ChatParams,
+    messages: ChatMessage[],
+    privateChats: Record<string, ChatMessage[]>,
+    sessions: Record<string, { user: string; last: number }>,
+    u: string,
+    now: number,
+): { message: string } {
+    const { message, session, token } = params;
+
+    if (!message) throw new Error('Please provide a message');
+    if (!session) throw new Error('Please provide a valid session ID');
+
+    if (sessions[u] && sessions[u].user !== session) {
+        throw new Error('Session ID mismatch');
+    }
+
+    const msg: ChatMessage = {
+        username: params.username,
+        message,
+        timestamp: params.timestamp || new Date().toISOString(),
+    };
+
+    if (token) {
+        privateChats[token] = privateChats[token] || [];
+        privateChats[token]!.push(msg);
+        setTimeout(() => {
+            delete privateChats[token];
+        }, SESSION_TTL);
+    } else {
+        messages.push(msg);
+        setTimeout(() => messages.splice(messages.indexOf(msg), 1), 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: 'Message sent successfully' };
+}
+
+function getPrivateChat(params: ChatParams, privateChats: Record<string, ChatMessage[]>): ChatMessage[] {
+    const { token } = params;
+
+    if (!token) throw new Error('Please provide a valid token');
+
+    if (privateChats[token]) return privateChats[token];
+
+    throw new Error('Invalid or expired token.');
+}
+
+function fetchMessages(messages: ChatMessage[]): ChatMessage[] {
+    if (messages.length > 0) return messages;
+    throw new Error('No messages stored.');
+}
+
+function clearPrivateChat(
+    params: ChatParams,
+    privateChats: Record<string, ChatMessage[]>,
+    sessions: Record<string, { user: string; last: number }>,
+    u: string,
+): { message: string } {
+    const { token, session } = params;
+
+    if (!token) throw new Error('Please provide a valid token');
+    if (!session) throw new Error('Please provide a valid session ID');
+    if (sessions[u] && sessions[u].user !== session) {
+        throw new Error('Session ID mismatch');
+    }
+    if (!privateChats[token]) throw new Error('Invalid or expired token.');
+
+    delete privateChats[token];
+    delete sessions[u];
+
+    return { message: 'Private chat cleared successfully' };
+}

package/src/modules/v4/color.ts

@@ -0,0 +1,64 @@
+export default function color(): Record<string, string> {
+    const r = Math.floor(Math.random() * 256),
+        g = Math.floor(Math.random() * 256),
+        b = Math.floor(Math.random() * 256);
+
+    const hsl = ((): [number, number, number] => {
+        const r1 = r / 255,
+            g1 = g / 255,
+            b1 = b / 255,
+            max = Math.max(r1, g1, b1),
+            min = Math.min(r1, g1, b1),
+            l = (max + min) / 2;
+        if (max === min) return [0, 0, l * 100];
+        const d = max - min,
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        const h =
+            {
+                [r1]: (g1 - b1) / d + (g1 < b1 ? 6 : 0),
+                [g1]: (b1 - r1) / d + 2,
+                [b1]: (r1 - g1) / d + 4,
+            }[max] ?? 0;
+        return [(h * 60) % 360, s * 100, l * 100];
+    })();
+
+    const hsv = ((): [number, number, number] => {
+        const max = Math.max(r, g, b),
+            min = Math.min(r, g, b),
+            v = max / 255,
+            s = max ? (max - min) / max : 0;
+        const h =
+            max === min
+                ? 0
+                : ({
+                      [r]: (g - b) / (max - min),
+                      [g]: 2 + (b - r) / (max - min),
+                      [b]: 4 + (r - g) / (max - min),
+                  }[max] ?? 0);
+        return [(h * 60) % 360, s * 100, v * 100];
+    })();
+
+    const hwb = ((): [number, number, number] => {
+        const [h] = hsv,
+            whiteness = Math.min(r, g, b) / 255,
+            blackness = 1 - Math.max(r, g, b) / 255;
+        return [h, whiteness * 100, blackness * 100];
+    })();
+
+    const cmyk = ((): [number, number, number, number] => {
+        const k = 1 - Math.max(r, g, b) / 255,
+            c = (1 - r / 255 - k) / (1 - k) || 0,
+            m = (1 - g / 255 - k) / (1 - k) || 0,
+            y = (1 - b / 255 - k) / (1 - k) || 0;
+        return [c * 100, m * 100, y * 100, k * 100];
+    })();
+
+    return {
+        hex: `#${[r, g, b].map((x) => x.toString(16).padStart(2, '0')).join('')}`,
+        rgb: `rgb(${r}, ${g}, ${b})`,
+        hsl: `hsl(${hsl[0].toFixed(1)}, ${hsl[1].toFixed(1)}%, ${hsl[2].toFixed(1)}%)`,
+        hsv: `hsv(${hsv[0].toFixed(1)}, ${hsv[1].toFixed(1)}%, ${hsv[2].toFixed(1)}%)`,
+        hwb: `hwb(${hwb[0].toFixed(1)}, ${hwb[1].toFixed(1)}%, ${hwb[2].toFixed(1)}%)`,
+        cmyk: `cmyk(${cmyk.map((x) => x.toFixed(1)).join('%, ')}%)`,
+    };
+}

package/src/modules/v4/convert.ts

@@ -0,0 +1,38 @@
+import { MIN_TEMPERATURE, MAX_TEMPERATURE } from '../../constants.js';
+
+type ConversionFn = (val: number) => number;
+
+const conversions: Record<string, Record<string, ConversionFn>> = {
+    celsius: {
+        fahrenheit: (val) => (val * 9) / 5 + 32,
+        kelvin: (val) => val + 273.15,
+    },
+    fahrenheit: {
+        celsius: (val) => ((val - 32) * 5) / 9,
+        kelvin: (val) => ((val - 32) * 5) / 9 + 273.15,
+    },
+    kelvin: {
+        celsius: (val) => val - 273.15,
+        fahrenheit: (val) => ((val - 273.15) * 9) / 5 + 32,
+    },
+};
+
+export default function convert(
+    value: string | number,
+    from: string,
+    to: string,
+): { from: string; to: string; value: number; result: number } {
+    const convertFn = conversions[from.toLowerCase()]?.[to.toLowerCase()];
+
+    if (!convertFn) throw new Error('Invalid conversion unit');
+    if (isNaN(Number(value))) throw new Error('Value must be a number');
+    if (Number(value) < MIN_TEMPERATURE) throw new Error('Value must be greater than absolute zero');
+    if (Number(value) > MAX_TEMPERATURE) throw new Error('Value must be less than 1,000,000');
+
+    return {
+        from,
+        to,
+        value: parseFloat(String(value)),
+        result: convertFn(parseFloat(String(value))),
+    };
+}

package/src/modules/v4/dice.ts

@@ -0,0 +1,39 @@
+export interface DiceResult {
+    roll: string;
+    count: number;
+    sides: number;
+    modifier: number;
+    results: number[];
+    total: number;
+}
+
+export default function dice(roll: string): DiceResult {
+    if (!roll) throw new Error('A roll notation is required (e.g. 2d6+3)');
+    if (typeof roll !== 'string') throw new Error('Roll must be a string');
+
+    const match = /^(\d*)d(\d+)([+-]\d+)?$/i.exec(roll.trim().replace(/\s+/g, '+'));
+    if (!match) throw new Error('Invalid notation. Use NdX or NdX+M (e.g. 2d6+3)');
+
+    const count = match[1] ? parseInt(match[1], 10) : 1;
+    const sides = parseInt(match[2]!, 10);
+    const modifier = match[3] ? parseInt(match[3], 10) : 0;
+
+    if (count < 1 || count > 100) throw new Error('Number of dice must be between 1 and 100');
+    if (sides < 2 || sides > 1000) throw new Error('Number of sides must be between 2 and 1000');
+
+    const results: number[] = [];
+    for (let i = 0; i < count; i++) {
+        results.push(1 + Math.floor(Math.random() * sides));
+    }
+
+    const total = results.reduce((a, b) => a + b, 0) + modifier;
+
+    return {
+        roll: `${count}d${sides}${modifier ? (modifier > 0 ? `+${modifier}` : modifier) : ''}`,
+        count,
+        sides,
+        modifier,
+        results,
+        total,
+    };
+}

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(),
+    };
+}