@20syldev/api 3.4.9 → 4.0.0

package/{modules → src/modules}/v3/time.js

@@ -11,16 +11,27 @@
  */
 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'
+        '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'
-    ];
+    const validTimezones = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'];
 
     // Input validation
     if (type !== 'live' && type !== 'random') {
@@ -61,9 +72,9 @@ export default function time(type = 'live', start, end, format, timezone) {
             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),
+            weekNumber: Math.ceil(((date - new Date(date.getFullYear(), 0, 0)) / 86400000 + 1) / 7),
             timezone: tz,
-            timezoneOffset: date.getTimezoneOffset()
+            timezoneOffset: date.getTimezoneOffset(),
         };
     };
 
@@ -84,4 +95,4 @@ export default function time(type = 'live', start, end, format, timezone) {
     const formats = getTimeFormats(now, tz);
 
     return format ? { date: formats[format] } : formats;
-}
+}

package/src/modules/v3/token.js

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,94 @@
+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),
+    };
+}

package/{modules → src/modules}/v3/utils.js

@@ -65,7 +65,7 @@ export function envList(key) {
  * @throws {Error} - If rate limit is exceeded
  */
 export function checkRateLimit(rateLimits, userId, timestamp, window = 10000, limit = 50) {
-    rateLimits[userId] = (rateLimits[userId] || []).filter(ts => timestamp - ts < window);
+    rateLimits[userId] = (rateLimits[userId] || []).filter((ts) => timestamp - ts < window);
 
     if (rateLimits[userId].length > limit) {
         const remainingTime = Math.ceil((rateLimits[userId][0] + window - timestamp) / 1000);
@@ -74,4 +74,4 @@ export function checkRateLimit(rateLimits, userId, timestamp, window = 10000, li
 
     rateLimits[userId].push(timestamp);
     return false;
-}
+}

package/{modules → src/modules}/v3.js

@@ -12,4 +12,4 @@ export { default as qrcode } from './v3/qrcode.js';
 export { default as tic_tac_toe } from './v3/tic_tac_toe.js';
 export { default as time } from './v3/time.js';
 export { default as token } from './v3/token.js';
-export { default as username } from './v3/username.js';
+export { default as username } from './v3/username.js';

package/src/modules/v4/algorithms.ts

@@ -0,0 +1,155 @@
+import { MAX_FACTORIAL, MAX_GCD_VALUE, MAX_PRIME_LIST, MAX_STRING_LENGTH } 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('');
+}

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,99 @@
+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 {
+        throw new Error('Invalid action. Use "message", "private", or "fetch"');
+    }
+}
+
+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.');
+}

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