@20syldev/api 4.7.0 → 4.9.0

package/src/modules/v3/algorithms.js

@@ -1,218 +0,0 @@
-/**
- * Check if two strings are anagrams of each other
- *
- * @param {string} value - First string to compare
- * @param {string} value2 - Second string to compare
- * @returns {boolean} - True if strings are anagrams, false otherwise
- * @throws {Error} - If inputs are invalid
- */
-export function anagram(value, value2) {
-    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 > 1000) 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 > 1000) throw new Error('Second value must be less than 1000 characters long');
-
-    return value.split('').sort().join('') === value2.split('').sort().join('');
-}
-
-/**
- * Sort an array using bubble sort algorithm
- *
- * @param {string} value - Comma-separated list of numbers
- * @returns {number[]} - Sorted array of numbers
- * @throws {Error} - If input is invalid
- */
-export function bubblesort(value) {
-    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 > 1000) 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;
-}
-
-/**
- * Calculate the factorial of a number
- *
- * @param {number} value - Number to calculate factorial for
- * @returns {number} - Factorial result
- * @throws {Error} - If input is invalid or out of range
- */
-export function factorial(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 0) throw new Error('Number must be positive');
-    if (value > 170) throw new Error('Number must be between 0 and 170');
-
-    return value <= 1 ? 1 : value * factorial(value - 1);
-}
-
-/**
- * Generate a Fibonacci sequence up to the specified length
- *
- * @param {number} value - Length of Fibonacci sequence to generate
- * @returns {number[]} - Array of Fibonacci numbers
- * @throws {Error} - If input is invalid or out of range
- */
-export function fibonacci(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 0) throw new Error('Number must be positive');
-    if (value > 1000) throw new Error('Number must be between 0 and 1000');
-
-    let fib = [0, 1];
-
-    for (let i = 2; i < parseInt(value); i++) {
-        fib.push(fib[i - 1] + fib[i - 2]);
-    }
-
-    return fib.slice(0, parseInt(value));
-}
-
-/**
- * Calculate the greatest common divisor (GCD) of two numbers
- *
- * @param {number} value - First number
- * @param {number} value2 - Second number
- * @returns {number} - Greatest common divisor
- * @throws {Error} - If inputs are invalid or out of range
- */
-export function gcd(value, value2) {
-    if (isNaN(value)) throw new Error('First value must be a number');
-    if (isNaN(value2)) throw new Error('Second value must be a number');
-
-    if (value <= 0) throw new Error('First number must be strictly positive');
-    if (value2 <= 0) throw new Error('Second number must be strictly positive');
-
-    if (value > 100000) throw new Error('First number must be between 0 and 100000');
-    if (value2 > 100000) throw new Error('Second number must be between 0 and 100000');
-
-    value = Math.abs(value);
-    value2 = Math.abs(value2);
-
-    while (value2) [value, value2] = [value2, value % value2];
-
-    return value;
-}
-
-/**
- * Check if a number is prime
- *
- * @param {number} value - Number to check
- * @returns {boolean} - True if the number is prime, false otherwise
- * @throws {Error} - If input is invalid or out of range
- */
-export function isprime(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 1) throw new Error('Number must be positive');
-    if (value > 100000) throw new Error('Number must be between 1 and 100000');
-
-    for (let i = 2; i <= Math.sqrt(value); i++) {
-        if (value % i === 0) return false;
-    }
-
-    return true;
-}
-
-/**
- * Check if a string is a palindrome
- *
- * @param {string} value - String to check
- * @returns {boolean} - True if the string is a palindrome, false otherwise
- * @throws {Error} - If input is invalid
- */
-export function palindrome(value) {
-    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 > 1000) throw new Error('Value must be less than 1000 characters long');
-
-    return value === value.split('').reverse().join('');
-}
-
-/**
- * Find all prime factors of a number
- *
- * @param {number} value - Number to factorize
- * @returns {number[]} - Array of prime factors
- * @throws {Error} - If input is invalid or out of range
- */
-export function primefactors(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 2) throw new Error('Number must be positive and greater than 1');
-    if (value > 100000) throw new Error('Number must be between 2 and 100000');
-
-    const factors = [];
-
-    for (let i = 2; i <= value; i++) {
-        while (value % i === 0) {
-            factors.push(i);
-            value /= i;
-        }
-    }
-
-    return factors;
-}
-
-/**
- * Generate a list of all prime numbers up to the specified limit
- *
- * @param {number} value - Upper limit to check for primes
- * @returns {number[]} - Array of prime numbers
- * @throws {Error} - If input is invalid or out of range
- */
-export function primelist(value) {
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < 2) throw new Error('Number must be positive and greater than 1');
-    if (value > 10000) throw new Error('Number must be between 2 and 10000');
-
-    const primes = [];
-
-    for (let i = 2; i <= value; 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;
-}
-
-/**
- * Reverse a string
- *
- * @param {string} value - String to reverse
- * @returns {string} - Reversed string
- * @throws {Error} - If input is invalid
- */
-export function reverse(value) {
-    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/v3/captcha.js

@@ -1,60 +0,0 @@
-import { createCanvas } from 'canvas';
-
-/**
- * Generate a captcha image from the provided text
- *
- * @param {string} text - Text to render in the captcha image
- * @returns {Buffer} - PNG image buffer of the rendered captcha
- * @throws {Error} - If text is not provided
- */
-export default function captcha(text) {
-    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');
-
-    // Set white background
-    ctx.fillStyle = 'white';
-    ctx.fillRect(0, 0, width, height);
-
-    // Add random lines for noise
-    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;
-
-    // Draw each character with random rotation and color
-    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;
-    }
-
-    // Add noise dots
-    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/v3/chat.js

@@ -1,111 +0,0 @@
-import { checkRateLimit } from './utils.js';
-
-/**
- * Manages a chat system with public and private messages
- *
- * @param {string} action - The action to perform ('message' or 'private')
- * @param {Object} params - The parameters for the action
- * @returns {Object} - The result of the action
- * @throws {Error} - If parameters are invalid
- */
-export default function chat(action, params = {}) {
-    // In-memory storage
-    const storage = params.storage || {};
-
-    // Initialize storage
-    storage.messages ??= [];
-    storage.privateChats ??= {};
-    storage.sessions ??= {};
-    storage.rateLimits ??= {};
-
-    // Reference the storage properties
-    const { messages, privateChats, sessions, rateLimits } = storage;
-
-    // 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
-    checkRateLimit(rateLimits, u, now);
-
-    // Handle different actions
-    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"');
-    }
-}
-
-/**
- * Send a new message
- */
-function sendMessage(params, messages, privateChats, sessions, u, now) {
-    const { message, session, token } = params;
-
-    // Input validation for message action
-    if (!message) throw new Error('Please provide a message');
-    if (!session) throw new Error('Please provide a valid session ID');
-
-    // Session validation
-    if (sessions[u] && sessions[u].user !== session) {
-        throw new Error('Session ID mismatch');
-    }
-
-    // Create message object
-    const msg = {
-        username: params.username,
-        message,
-        timestamp: params.timestamp || new Date().toISOString(),
-    };
-
-    // Store message based on whether it's private or public
-    if (token) {
-        privateChats[token] = privateChats[token] || [];
-        privateChats[token].push(msg);
-        setTimeout(() => {
-            delete privateChats[token];
-        }, 3600000);
-    } else {
-        messages.push(msg);
-        setTimeout(() => messages.splice(messages.indexOf(msg), 1), 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: 'Message sent successfully' };
-}
-
-/**
- * Get private chat messages
- */
-function getPrivateChat(params, privateChats) {
-    const { token } = params;
-
-    // Input validation for private action
-    if (!token) throw new Error('Please provide a valid token');
-
-    // Return messages if token exists
-    if (privateChats[token]) return privateChats[token];
-
-    throw new Error('Invalid or expired token.');
-}
-
-/**
- * Fetch all public messages
- */
-function fetchMessages(messages) {
-    if (messages.length > 0) return messages;
-    throw new Error('No messages stored.');
-}

package/src/modules/v3/color.js

@@ -1,60 +0,0 @@
-/**
- * Generate a random color in multiple formats
- *
- * @returns {Object} Color in various formats (hex, rgb, hsl, hsv, hwb, cmyk)
- */
-export default function color() {
-    const r = Math.floor(Math.random() * 256),
-        g = Math.floor(Math.random() * 256),
-        b = Math.floor(Math.random() * 256);
-
-    const hsl = (() => {
-        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);
-        let h = { [r1]: (g1 - b1) / d + (g1 < b1 ? 6 : 0), [g1]: (b1 - r1) / d + 2, [b1]: (r1 - g1) / d + 4 }[max];
-        return [(h * 60) % 360, s * 100, l * 100];
-    })();
-
-    const hsv = (() => {
-        const max = Math.max(r, g, b),
-            min = Math.min(r, g, b),
-            v = max / 255,
-            s = max ? (max - min) / max : 0;
-        let h =
-            max === min
-                ? 0
-                : { [r]: (g - b) / (max - min), [g]: 2 + (b - r) / (max - min), [b]: 4 + (r - g) / (max - min) }[max];
-        return [(h * 60) % 360, s * 100, v * 100];
-    })();
-
-    const hwb = (() => {
-        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 = (() => {
-        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, m, y, k].map((x) => x * 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/v3/convert.js

@@ -1,39 +0,0 @@
-/**
- * Converts values between different temperature units
- *
- * @param {number|string} value - The value to convert
- * @param {string} from - The source unit (celsius, fahrenheit, or kelvin)
- * @param {string} to - The target unit (celsius, fahrenheit, or kelvin)
- * @returns {Object} - Object containing the conversion details
- * @throws {Error} - If conversion parameters are invalid
- */
-export default function convert(value, from, to) {
-    const conversions = {
-        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,
-        },
-    };
-
-    const convert = conversions[from.toLowerCase()]?.[to.toLowerCase()];
-
-    if (!convert) throw new Error('Invalid conversion unit');
-    if (isNaN(value)) throw new Error('Value must be a number');
-    if (value < -273.15) throw new Error('Value must be greater than absolute zero');
-    if (value > 1e6) throw new Error('Value must be less than 1,000,000');
-
-    return {
-        from,
-        to,
-        value: parseFloat(value),
-        result: convert(parseFloat(value)),
-    };
-}

package/src/modules/v3/domain.js

@@ -1,86 +0,0 @@
-import { random, genIP } from './utils.js';
-
-/**
- * Generate random domain information
- *
- * @returns {Object} Domain details including DNS, hosting, and SEO metrics
- */
-export default function domain() {
-    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 domain = `${random(domains)}${random(tlds)}`;
-    const fulldomain = `${random(subdomains)}${domain}`;
-
-    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,
-        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: domain.split('.')[0],
-        random_subdomain: fulldomain.split('.')[0],
-        random_tld: domain.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(),
-    };
-}

package/src/modules/v3/hash.js

@@ -1,16 +0,0 @@
-import { getHashes, createHash } from 'crypto';
-
-/**
- * Generate a hash of text using the specified algorithm
- *
- * @param {string} text - The text to hash
- * @param {string} method - The hash algorithm to use
- * @returns {Object} Object containing the method and resulting hash
- */
-export default function hash(text, method) {
-    const methods = getHashes();
-    if (!methods.includes(method)) return { error: `Unsupported method. Use one of: ${methods.join(', ')}` };
-
-    const hash = createHash(method).update(text).digest('hex');
-    return { method, hash };
-}

package/src/modules/v3/hyperplanning.js

@@ -1,56 +0,0 @@
-import { formatDate } from './utils.js';
-import ical from 'ical.js';
-
-/**
- * Parse an ICS calendar file and extract event information
- *
- * @param {string} url - URL to the ICS file
- * @param {string} [detail] - Detail level of returned information ('full', 'list', or undefined)
- * @returns {Promise<Array>} Array of calendar events
- * @throws {Error} If the ICS file is invalid or inaccessible
- */
-export default async function hyperplanning(url, detail) {
-    const response = await fetch(url);
-
-    if (!response.ok || !(response.headers.get('content-type') || '').includes('text/calendar')) {
-        throw new Error('Invalid ICS file format.');
-    }
-
-    const events = new ical.Component(ical.parse(await response.text()))
-        .getAllSubcomponents('vevent')
-        .map((e) => {
-            const evt = new ical.Event(e);
-            const summary = (evt.summary || '').split(' ').filter((part) => part !== '-');
-            const start = formatDate(evt.startDate.toJSDate());
-            const end = formatDate(evt.endDate.toJSDate());
-
-            if (detail === 'full') {
-                const desc = (evt.description || '').split('\n').map((l) => l.trim());
-                const extract = (p) => (desc.find((l) => l.startsWith(p)) || '').replace(p, '').trim();
-
-                return {
-                    summary,
-                    subject: extract('Matière :'),
-                    teacher: extract('Enseignant :'),
-                    classes: extract('Promotions :')
-                        .split(', ')
-                        .map((c) => c.trim()),
-                    type: extract('Salle :') || undefined,
-                    start,
-                    end,
-                };
-            }
-
-            if (detail === 'list') return { summary, start, end };
-
-            return {
-                summary: evt.summary || '',
-                start,
-                end,
-            };
-        })
-        .sort((a, b) => new Date(a.start) - new Date(b.start))
-        .filter((e) => new Date(e.end) >= new Date());
-
-    return events;
-}

package/src/modules/v3/levenshtein.js

@@ -1,46 +0,0 @@
-/**
- * Calculate the Levenshtein distance between two strings.
- *
- * @param {string} str1 - The first string
- * @param {string} str2 - The second string
- * @returns {object} - Object containing the strings and their Levenshtein distance
- * @throws {Error} - If inputs are invalid
- */
-export default function levenshtein(str1, str2) {
-    // Input validation
-    if (!str1 || typeof str1 !== 'string') {
-        throw new Error('Please provide a valid first string');
-    }
-
-    if (!str2 || typeof str2 !== 'string') {
-        throw new Error('Please provide a valid second string');
-    }
-
-    if (str1.length > 1000) {
-        throw new Error('First string exceeds 1000 characters');
-    }
-
-    if (str2.length > 1000) {
-        throw new Error('Second string exceeds 1000 characters');
-    }
-
-    // Calculate Levenshtein distance
-    const m = Array.from({ length: str1.length + 1 }, (_, i) => [i]);
-    for (let j = 0; j <= str2.length; j++) m[0][j] = j;
-
-    for (let i = 1; i <= str1.length; i++) {
-        for (let j = 1; j <= str2.length; j++) {
-            m[i][j] = Math.min(
-                m[i - 1][j] + 1,
-                m[i][j - 1] + 1,
-                m[i - 1][j - 1] + (str1[i - 1] !== str2[j - 1] ? 1 : 0),
-            );
-        }
-    }
-
-    return {
-        str1,
-        str2,
-        distance: m[str1.length][str2.length],
-    };
-}