@20syldev/api 3.4.0 → 3.4.1

package/modules/v3/chat.js

@@ -1,109 +1,109 @@
-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.');
+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/modules/v3/color.js

@@ -1,41 +1,41 @@
-/**
- * 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('%, ')}%)`
-    };
+/**
+ * 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/modules/v3/convert.js

@@ -1,39 +1,39 @@
-/**
- * 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))
-    };
+/**
+ * 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/modules/v3/domain.js

@@ -1,39 +1,39 @@
-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(),
-    };
+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/modules/v3/hash.js

@@ -1,16 +1,16 @@
-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 };
+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/modules/v3/hyperplanning.js

@@ -1,51 +1,51 @@
-import { formatDate } from './utils.js';
-import ical from 'ical.js';
-import fetch from 'node-fetch';
-
-/**
- * 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;
+import { formatDate } from './utils.js';
+import ical from 'ical.js';
+import fetch from 'node-fetch';
+
+/**
+ * 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;
 }