@20syldev/api 4.8.0 → 4.9.0

package/src/modules/v4/convert.ts

@@ -1,127 +0,0 @@
-type ConversionFn = (val: number) => number;
-
-const TEMPERATURE_UNITS = new Set(['celsius', 'fahrenheit', 'kelvin']);
-const ABSOLUTE_ZERO: Record<string, number> = { celsius: -273.15, fahrenheit: -459.67, kelvin: 0 };
-
-const conversions: Record<string, Record<string, ConversionFn>> = {
-    // Temperature
-    celsius: {
-        fahrenheit: (v) => (v * 9) / 5 + 32,
-        kelvin: (v) => v + 273.15,
-    },
-    fahrenheit: {
-        celsius: (v) => ((v - 32) * 5) / 9,
-        kelvin: (v) => ((v - 32) * 5) / 9 + 273.15,
-    },
-    kelvin: {
-        celsius: (v) => v - 273.15,
-        fahrenheit: (v) => ((v - 273.15) * 9) / 5 + 32,
-    },
-
-    // Length
-    km: {
-        mi: (v) => v * 0.621371,
-        m: (v) => v * 1000,
-        ft: (v) => v * 3280.84,
-        cm: (v) => v * 100000,
-        in: (v) => v * 39370.1,
-        yd: (v) => v * 1093.61,
-    },
-    mi: {
-        km: (v) => v * 1.60934,
-        m: (v) => v * 1609.34,
-        ft: (v) => v * 5280,
-        cm: (v) => v * 160934,
-        in: (v) => v * 63360,
-        yd: (v) => v * 1760,
-    },
-    m: {
-        km: (v) => v / 1000,
-        mi: (v) => v * 0.000621371,
-        ft: (v) => v * 3.28084,
-        cm: (v) => v * 100,
-        in: (v) => v * 39.3701,
-        yd: (v) => v * 1.09361,
-    },
-    ft: {
-        km: (v) => v * 0.0003048,
-        mi: (v) => v / 5280,
-        m: (v) => v * 0.3048,
-        cm: (v) => v * 30.48,
-        in: (v) => v * 12,
-        yd: (v) => v / 3,
-    },
-    cm: {
-        km: (v) => v / 100000,
-        mi: (v) => v / 160934,
-        m: (v) => v / 100,
-        ft: (v) => v / 30.48,
-        in: (v) => v / 2.54,
-        yd: (v) => v / 91.44,
-    },
-    in: {
-        km: (v) => v / 39370.1,
-        mi: (v) => v / 63360,
-        m: (v) => v * 0.0254,
-        ft: (v) => v / 12,
-        cm: (v) => v * 2.54,
-        yd: (v) => v / 36,
-    },
-    yd: {
-        km: (v) => v * 0.0009144,
-        mi: (v) => v / 1760,
-        m: (v) => v * 0.9144,
-        ft: (v) => v * 3,
-        cm: (v) => v * 91.44,
-        in: (v) => v * 36,
-    },
-
-    // Weight
-    kg: { lb: (v) => v * 2.20462, oz: (v) => v * 35.274, g: (v) => v * 1000, ton: (v) => v / 1000 },
-    lb: { kg: (v) => v * 0.453592, oz: (v) => v * 16, g: (v) => v * 453.592, ton: (v) => v * 0.000453592 },
-    oz: { kg: (v) => v * 0.0283495, lb: (v) => v / 16, g: (v) => v * 28.3495, ton: (v) => v * 0.0000283495 },
-    g: { kg: (v) => v / 1000, lb: (v) => v * 0.00220462, oz: (v) => v * 0.035274, ton: (v) => v / 1000000 },
-    ton: { kg: (v) => v * 1000, lb: (v) => v * 2204.62, oz: (v) => v * 35274, g: (v) => v * 1000000 },
-
-    // Data
-    b: { kb: (v) => v / 1024, mb: (v) => v / 1048576, gb: (v) => v / 1073741824, tb: (v) => v / 1099511627776 },
-    kb: { b: (v) => v * 1024, mb: (v) => v / 1024, gb: (v) => v / 1048576, tb: (v) => v / 1073741824 },
-    mb: { b: (v) => v * 1048576, kb: (v) => v * 1024, gb: (v) => v / 1024, tb: (v) => v / 1048576 },
-    gb: { b: (v) => v * 1073741824, kb: (v) => v * 1048576, mb: (v) => v * 1024, tb: (v) => v / 1024 },
-    tb: { b: (v) => v * 1099511627776, kb: (v) => v * 1073741824, mb: (v) => v * 1048576, gb: (v) => v * 1024 },
-
-    // Speed
-    'km/h': { mph: (v) => v * 0.621371, 'm/s': (v) => v / 3.6, knots: (v) => v * 0.539957 },
-    mph: { 'km/h': (v) => v * 1.60934, 'm/s': (v) => v * 0.44704, knots: (v) => v * 0.868976 },
-    'm/s': { 'km/h': (v) => v * 3.6, mph: (v) => v * 2.23694, knots: (v) => v * 1.94384 },
-    knots: { 'km/h': (v) => v * 1.852, mph: (v) => v * 1.15078, 'm/s': (v) => v * 0.514444 },
-};
-
-/**
- * Converts a numeric value from one unit to another.
- *
- * @param value - The numeric value to convert
- * @param from - The source unit (e.g. "km", "celsius", "kg")
- * @param to - The target unit (e.g. "mi", "fahrenheit", "lb")
- * @returns Object with source unit, target unit, original value, and converted result
- * @throws Error if the conversion pair is unsupported, the value is NaN, or the temperature is below absolute zero
- */
-export default function convert(
-    value: number,
-    from: string,
-    to: string,
-): { from: string; to: string; value: number; result: number } {
-    const fromKey = from.toLowerCase();
-    const toKey = to.toLowerCase();
-    const convertFn = conversions[fromKey]?.[toKey];
-
-    if (!convertFn) throw new Error('Invalid conversion unit');
-    if (isNaN(value)) throw new Error('Value must be a number');
-
-    if (TEMPERATURE_UNITS.has(fromKey)) {
-        const minValue = ABSOLUTE_ZERO[fromKey]!;
-        if (value < minValue) throw new Error('Value must be greater than absolute zero');
-    }
-
-    return { from, to, value, result: convertFn(value) };
-}

package/src/modules/v4/cron.ts

@@ -1,221 +0,0 @@
-import { MAX_CRON_ITERATIONS, MAX_CRON_RESULTS } from '../../constants.js';
-import { VALID_TIMEZONES } from './time.js';
-
-type Timezone = (typeof VALID_TIMEZONES)[number];
-
-const FIELD_RANGES = [
-    { min: 0, max: 59 }, // minute
-    { min: 0, max: 23 }, // hour
-    { min: 1, max: 31 }, // day of month
-    { min: 1, max: 12 }, // month
-    { min: 0, max: 7 }, // day of week (0 and 7 = Sunday)
-] as const;
-
-const DOW_NAMES: Record<string, number> = {
-    Sunday: 0,
-    Monday: 1,
-    Tuesday: 2,
-    Wednesday: 3,
-    Thursday: 4,
-    Friday: 5,
-    Saturday: 6,
-};
-
-const DOW_DISPLAY = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-
-export interface CronResult {
-    expression: string;
-    description: string;
-    next: string[];
-    timezone: string;
-}
-
-function parseField(field: string, range: { min: number; max: number }): Set<number> {
-    const result = new Set<number>();
-
-    for (const part of field.split(',')) {
-        if (part === '*') {
-            for (let i = range.min; i <= range.max; i++) result.add(i);
-        } else if (part.startsWith('*/')) {
-            const step = parseInt(part.slice(2), 10);
-            if (isNaN(step) || step < 1) throw new Error(`Invalid step in "${part}"`);
-            for (let i = range.min; i <= range.max; i += step) result.add(i);
-        } else if (part.includes('-')) {
-            const [s, e] = part.split('-');
-            const start = parseInt(s!, 10);
-            const end = parseInt(e!, 10);
-            if (isNaN(start) || isNaN(end) || start < range.min || end > range.max || start > end) {
-                throw new Error(`Invalid range "${part}" (valid: ${range.min}-${range.max})`);
-            }
-            for (let i = start; i <= end; i++) result.add(i);
-        } else {
-            const val = parseInt(part, 10);
-            if (isNaN(val) || val < range.min || val > range.max) {
-                throw new Error(`Invalid value "${part}" (valid: ${range.min}-${range.max})`);
-            }
-            result.add(val);
-        }
-    }
-
-    return result;
-}
-
-function getComponents(
-    date: Date,
-    formatter: Intl.DateTimeFormat,
-): { minute: number; hour: number; dom: number; month: number; dow: number } {
-    const parts = Object.fromEntries(formatter.formatToParts(date).map((p) => [p.type, p.value]));
-    return {
-        minute: parseInt(parts.minute!, 10),
-        hour: parseInt(parts.hour!, 10) % 24,
-        dom: parseInt(parts.day!, 10),
-        month: parseInt(parts.month!, 10),
-        dow: DOW_NAMES[parts.weekday!] ?? 0,
-    };
-}
-
-function pad(n: number): string {
-    return String(n).padStart(2, '0');
-}
-
-function formatDow(field: string): string {
-    if (field === '1-5') return 'Monday through Friday';
-    if (field === '0' || field === '7') return 'Sunday';
-    if (field === '6') return 'Saturday';
-    const n = parseInt(field, 10);
-    if (!isNaN(n)) return DOW_DISPLAY[n % 7] ?? field;
-    return field;
-}
-
-function describe(fields: string[]): string {
-    const [mF, hF, domF, monthF, dowF] = fields as [string, string, string, string, string];
-
-    const isAll = (f: string) => f === '*';
-    const isFixed = (f: string) => /^\d+$/.test(f);
-    const isStep = (f: string) => /^\*\/\d+$/.test(f);
-
-    // Every minute
-    if (isAll(mF) && isAll(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
-        return 'Every minute';
-    }
-
-    // Every N minutes (whole day, every day)
-    if (isStep(mF) && isAll(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
-        const n = mF.slice(2);
-        return `Every ${n} minute${n === '1' ? '' : 's'}`;
-    }
-
-    // Every hour at minute 0
-    if (mF === '0' && isAll(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
-        return 'Every hour';
-    }
-
-    // Every N hours at minute 0
-    if (mF === '0' && isStep(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
-        const n = hF.slice(2);
-        return `Every ${n} hour${n === '1' ? '' : 's'}`;
-    }
-
-    // At specific time daily
-    if (isFixed(mF) && isFixed(hF) && isAll(domF) && isAll(monthF) && isAll(dowF)) {
-        return `At ${pad(parseInt(hF))}:${pad(parseInt(mF))} daily`;
-    }
-
-    // At specific time on specific weekday(s)
-    if (isFixed(mF) && isFixed(hF) && isAll(domF) && isAll(monthF) && !isAll(dowF)) {
-        return `At ${pad(parseInt(hF))}:${pad(parseInt(mF))}, ${formatDow(dowF)}`;
-    }
-
-    // At specific time on specific day of month
-    if (isFixed(mF) && isFixed(hF) && isFixed(domF) && isAll(monthF) && isAll(dowF)) {
-        return `At ${pad(parseInt(hF))}:${pad(parseInt(mF))}, on day ${domF} of the month`;
-    }
-
-    // Every N minutes, within hour range, optionally filtered by weekday
-    if (isStep(mF) && !isAll(hF) && isAll(domF) && isAll(monthF)) {
-        const n = mF.slice(2);
-        const parts = [`Every ${n} minute${n === '1' ? '' : 's'}`];
-        if (hF.includes('-')) {
-            const [h1, h2] = hF.split('-');
-            parts.push(`between ${pad(parseInt(h1!))}:00 and ${pad(parseInt(h2!))}:59`);
-        }
-        if (!isAll(dowF)) parts.push(formatDow(dowF));
-        return parts.join(', ');
-    }
-
-    return `At cron schedule: ${fields.join(' ')}`;
-}
-
-/**
- * Parses a cron expression and returns the next scheduled execution dates.
- *
- * @param expr - Cron expression with 5 space-separated fields (minute hour dom month dow)
- * @param count - Number of next executions to return (1–20, default 5)
- * @param from - Starting date in ISO 8601 format (defaults to now)
- * @param timezone - Timezone to evaluate the expression in (default "UTC")
- * @returns Parsed expression with description and list of next execution timestamps
- * @throws Error if the expression is invalid, count is out of range, or timezone is unsupported
- */
-export default function cron(expr: string, count: number = 5, from?: string, timezone: string = 'UTC'): CronResult {
-    if (!expr) throw new Error('Please provide a cron expression (?expr=* * * * *)');
-
-    if (!VALID_TIMEZONES.includes(timezone as Timezone)) {
-        throw new Error(`Please provide a valid timezone. Options: ${VALID_TIMEZONES.join(', ')}`);
-    }
-
-    const fields = expr.trim().split(/\s+/);
-    if (fields.length !== 5) {
-        throw new Error('Cron expression must have exactly 5 fields (minute hour dom month dow)');
-    }
-
-    if (count < 1 || count > MAX_CRON_RESULTS) {
-        throw new Error(`Count must be between 1 and ${MAX_CRON_RESULTS}`);
-    }
-
-    const fromMs = from ? new Date(from).getTime() : Date.now();
-    if (from && isNaN(fromMs)) throw new Error('Please provide a valid from date (ISO 8601)');
-
-    const sets = fields.map((f, i) => parseField(f, FIELD_RANGES[i]!));
-    const [minuteSet, hourSet, domSet, monthSet, dowSet] = sets as [
-        Set<number>,
-        Set<number>,
-        Set<number>,
-        Set<number>,
-        Set<number>,
-    ];
-
-    // Normalize DOW: treat 7 as Sunday (0)
-    if (dowSet.has(7)) {
-        dowSet.add(0);
-        dowSet.delete(7);
-    }
-
-    const formatter = new Intl.DateTimeFormat('en-US', {
-        timeZone: timezone,
-        month: 'numeric',
-        day: 'numeric',
-        hour: 'numeric',
-        minute: 'numeric',
-        weekday: 'long',
-        hour12: false,
-    });
-
-    // Always start from the next minute (never include the current minute)
-    let currentMs = (Math.floor(fromMs / 60000) + 1) * 60000;
-
-    const next: string[] = [];
-    let iterations = 0;
-
-    while (next.length < count && iterations < MAX_CRON_ITERATIONS) {
-        const { minute, hour, dom, month, dow } = getComponents(new Date(currentMs), formatter);
-
-        if (minuteSet.has(minute) && hourSet.has(hour) && domSet.has(dom) && monthSet.has(month) && dowSet.has(dow)) {
-            next.push(new Date(currentMs).toISOString());
-        }
-
-        currentMs += 60000;
-        iterations++;
-    }
-
-    return { expression: expr.trim(), description: describe(fields), next, timezone };
-}

package/src/modules/v4/dice.ts

@@ -1,46 +0,0 @@
-export interface DiceResult {
-    roll: string;
-    count: number;
-    sides: number;
-    modifier: number;
-    results: number[];
-    total: number;
-}
-
-/**
- * Rolls dice using standard tabletop notation and returns individual results with a total.
- *
- * @param roll - Dice notation string (e.g. "2d6+3", "d20", "4d8-1")
- * @returns Roll breakdown including count, sides, modifier, individual results, and total
- * @throws Error if the notation is missing, invalid, or out of bounds
- */
-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

@@ -1,86 +0,0 @@
-import { genIP, random } from '../../utils/helpers.js';
-
-/**
- * Generates a randomized fictional domain profile with metadata.
- *
- * @returns Object containing domain name, IP addresses, DNS info, SEO score, and other domain attributes
- */
-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(),
-    };
-}