@20syldev/api 3.5.0 → 4.1.0

package/src/modules/v4/encode.ts

@@ -0,0 +1,170 @@
+import { MAX_STRING_LENGTH } from '../../constants.js';
+
+const MORSE_TABLE: Record<string, string> = {
+    A: '.-',
+    B: '-...',
+    C: '-.-.',
+    D: '-..',
+    E: '.',
+    F: '..-.',
+    G: '--.',
+    H: '....',
+    I: '..',
+    J: '.---',
+    K: '-.-',
+    L: '.-..',
+    M: '--',
+    N: '-.',
+    O: '---',
+    P: '.--.',
+    Q: '--.-',
+    R: '.-.',
+    S: '...',
+    T: '-',
+    U: '..-',
+    V: '...-',
+    W: '.--',
+    X: '-..-',
+    Y: '-.--',
+    Z: '--..',
+    '0': '-----',
+    '1': '.----',
+    '2': '..---',
+    '3': '...--',
+    '4': '....-',
+    '5': '.....',
+    '6': '-....',
+    '7': '--...',
+    '8': '---..',
+    '9': '----.',
+    '.': '.-.-.-',
+    ',': '--..--',
+    '?': '..--..',
+    "'": '.----.',
+    '!': '-.-.--',
+    '/': '-..-.',
+    '(': '-.--.',
+    ')': '-.--.-',
+    '&': '.-...',
+    ':': '---...',
+    ';': '-.-.-.',
+    '=': '-...-',
+    '+': '.-.-.',
+    '-': '-....-',
+    _: '..--.-',
+    '"': '.-..-.',
+    $: '...-..-',
+    '@': '.--.-.',
+};
+
+const MORSE_REVERSE: Record<string, string> = Object.fromEntries(Object.entries(MORSE_TABLE).map(([k, v]) => [v, k]));
+
+function checkText(value: string): void {
+    if (!value) throw new Error('A value is required');
+    if (typeof value !== 'string') throw new Error('Value must be a string');
+    if (value.length > MAX_STRING_LENGTH)
+        throw new Error(`Value must be less than ${MAX_STRING_LENGTH} characters long`);
+}
+
+export function base64encode(value: string): string {
+    checkText(value);
+    return Buffer.from(value, 'utf-8').toString('base64');
+}
+
+export function base64decode(value: string): string {
+    checkText(value);
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value)) throw new Error('Invalid Base64 string');
+    return Buffer.from(value, 'base64').toString('utf-8');
+}
+
+export function urlencode(value: string): string {
+    checkText(value);
+    return encodeURIComponent(value);
+}
+
+export function urldecode(value: string): string {
+    checkText(value);
+    try {
+        return decodeURIComponent(value);
+    } catch {
+        throw new Error('Invalid URL-encoded string');
+    }
+}
+
+export function morse(value: string): string {
+    checkText(value);
+    return value
+        .toUpperCase()
+        .split(' ')
+        .map((word) =>
+            word
+                .split('')
+                .map((c) => {
+                    if (c === '\n' || c === '\t') return '';
+                    const code = MORSE_TABLE[c];
+                    if (!code) throw new Error(`Unsupported character in Morse code: '${c}'`);
+                    return code;
+                })
+                .filter(Boolean)
+                .join(' '),
+        )
+        .join(' / ');
+}
+
+export function unmorse(value: string): string {
+    checkText(value);
+    return value
+        .split(' / ')
+        .map((word) =>
+            word
+                .split(' ')
+                .map((code) => {
+                    if (!code) return '';
+                    const char = MORSE_REVERSE[code];
+                    if (!char) throw new Error(`Unsupported Morse sequence: '${code}'`);
+                    return char;
+                })
+                .join(''),
+        )
+        .join(' ');
+}
+
+export function rot13(value: string): string {
+    checkText(value);
+    return value.replace(/[a-zA-Z]/g, (c) => {
+        const base = c <= 'Z' ? 65 : 97;
+        return String.fromCharCode(((c.charCodeAt(0) - base + 13) % 26) + base);
+    });
+}
+
+export function caesar(value: string, shift: string): string {
+    checkText(value);
+    const n = Number(shift);
+    if (isNaN(n)) throw new Error('Shift must be a number');
+    const s = ((n % 26) + 26) % 26;
+    return value.replace(/[a-zA-Z]/g, (c) => {
+        const base = c <= 'Z' ? 65 : 97;
+        return String.fromCharCode(((c.charCodeAt(0) - base + s) % 26) + base);
+    });
+}
+
+export function binary(value: string): string {
+    checkText(value);
+    return value
+        .split('')
+        .map((c) => c.charCodeAt(0).toString(2).padStart(8, '0'))
+        .join(' ');
+}
+
+export function unbinary(value: string): string {
+    checkText(value);
+    if (!/^[01\s]+$/.test(value)) throw new Error('Invalid binary string');
+    return value
+        .trim()
+        .split(/\s+/)
+        .map((b) => {
+            if (b.length !== 8) throw new Error('Each binary group must contain 8 bits');
+            return String.fromCharCode(parseInt(b, 2));
+        })
+        .join('');
+}

package/src/modules/v4/geo.ts

@@ -0,0 +1,53 @@
+export interface GeoResult {
+    distance: { km: number; miles: number; nauticalMiles: number };
+    bearing: { degrees: number; cardinal: string };
+    from: { lat: number; lon: number };
+    to: { lat: number; lon: number };
+}
+
+const EARTH_RADIUS_KM = 6371;
+const CARDINALS = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
+
+function toRad(deg: number): number {
+    return (deg * Math.PI) / 180;
+}
+
+function toDeg(rad: number): number {
+    return (rad * 180) / Math.PI;
+}
+
+function parseCoord(value: string, name: string, min: number, max: number): number {
+    const n = Number(value);
+    if (isNaN(n)) throw new Error(`${name} must be a number`);
+    if (n < min || n > max) throw new Error(`${name} must be between ${min} and ${max}`);
+    return n;
+}
+
+export default function geo(lat1: string, lon1: string, lat2: string, lon2: string): GeoResult {
+    const a = parseCoord(lat1, 'lat1', -90, 90);
+    const b = parseCoord(lon1, 'lon1', -180, 180);
+    const c = parseCoord(lat2, 'lat2', -90, 90);
+    const d = parseCoord(lon2, 'lon2', -180, 180);
+
+    const dLat = toRad(c - a);
+    const dLon = toRad(d - b);
+    const sa = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(a)) * Math.cos(toRad(c)) * Math.sin(dLon / 2) ** 2;
+    const distance = 2 * EARTH_RADIUS_KM * Math.asin(Math.sqrt(sa));
+
+    const y = Math.sin(toRad(d - b)) * Math.cos(toRad(c));
+    const x =
+        Math.cos(toRad(a)) * Math.sin(toRad(c)) - Math.sin(toRad(a)) * Math.cos(toRad(c)) * Math.cos(toRad(d - b));
+    const bearing = (toDeg(Math.atan2(y, x)) + 360) % 360;
+    const cardinal = CARDINALS[Math.round(bearing / 22.5) % 16]!;
+
+    return {
+        distance: {
+            km: +distance.toFixed(3),
+            miles: +(distance * 0.621371).toFixed(3),
+            nauticalMiles: +(distance * 0.539957).toFixed(3),
+        },
+        bearing: { degrees: +bearing.toFixed(2), cardinal },
+        from: { lat: a, lon: b },
+        to: { lat: c, lon: d },
+    };
+}

package/src/modules/v4/hash.ts

@@ -0,0 +1,9 @@
+import { getHashes, createHash } from 'crypto';
+
+export default function hash(text: string, method: string): { method: string; hash: string } | { error: string } {
+    const methods = getHashes();
+    if (!methods.includes(method)) return { error: `Unsupported method. Use one of: ${methods.join(', ')}` };
+
+    const result = createHash(method).update(text).digest('hex');
+    return { method, hash: result };
+}

package/src/modules/v4/hyperplanning.ts

@@ -0,0 +1,58 @@
+import { formatDate } from './utils.js';
+import ical from 'ical.js';
+
+interface CalendarEvent {
+    summary: string[] | string;
+    subject?: string;
+    teacher?: string;
+    classes?: string[];
+    type?: string;
+    start: string;
+    end: string;
+}
+
+export default async function hyperplanning(url: string, detail?: string): Promise<CalendarEvent[]> {
+    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: CalendarEvent[] = new ical.Component(ical.parse(await response.text()))
+        .getAllSubcomponents('vevent')
+        .map((e: ical.Component) => {
+            const evt = new ical.Event(e);
+            const summary = (evt.summary || '').split(' ').filter((part: string) => part !== '-');
+            const start = formatDate(evt.startDate.toJSDate());
+            const end = formatDate(evt.endDate.toJSDate());
+
+            if (detail === 'full') {
+                const desc = (evt.description || '').split('\n').map((l: string) => l.trim());
+                const extract = (p: string) => (desc.find((l: string) => l.startsWith(p)) || '').replace(p, '').trim();
+
+                return {
+                    summary,
+                    subject: extract('Matière :'),
+                    teacher: extract('Enseignant :'),
+                    classes: extract('Promotions :')
+                        .split(', ')
+                        .map((c: string) => c.trim()),
+                    type: extract('Salle :') || undefined,
+                    start,
+                    end,
+                };
+            }
+
+            if (detail === 'list') return { summary, start, end };
+
+            return {
+                summary: evt.summary || '',
+                start,
+                end,
+            };
+        })
+        .sort((a: CalendarEvent, b: CalendarEvent) => new Date(a.start).getTime() - new Date(b.start).getTime())
+        .filter((e: CalendarEvent) => new Date(e.end) >= new Date());
+
+    return events;
+}

package/src/modules/v4/levenshtein.ts

@@ -0,0 +1,38 @@
+import { MAX_LEVENSHTEIN_LENGTH } from '../../constants.js';
+
+export default function levenshtein(str1: string, str2: string): { str1: string; str2: string; distance: number } {
+    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 > MAX_LEVENSHTEIN_LENGTH) {
+        throw new Error('First string exceeds 1000 characters');
+    }
+
+    if (str2.length > MAX_LEVENSHTEIN_LENGTH) {
+        throw new Error('Second string exceeds 1000 characters');
+    }
+
+    const m: number[][] = 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]!,
+    };
+}

package/src/modules/v4/palette.ts

@@ -0,0 +1,103 @@
+export interface PaletteColor {
+    hex: string;
+    rgb: string;
+    hsl: string;
+}
+
+export interface PaletteResult {
+    base: PaletteColor;
+    type: string;
+    colors: PaletteColor[];
+}
+
+function hexToRgb(hex: string): [number, number, number] {
+    const clean = hex.replace('#', '');
+    if (!/^[0-9a-fA-F]{6}$/.test(clean)) throw new Error('Invalid HEX color (use #RRGGBB)');
+    return [parseInt(clean.slice(0, 2), 16), parseInt(clean.slice(2, 4), 16), parseInt(clean.slice(4, 6), 16)];
+}
+
+function rgbToHsl(r: number, g: number, b: number): [number, number, number] {
+    const r1 = r / 255,
+        g1 = g / 255,
+        b1 = b / 255;
+    const max = Math.max(r1, g1, b1),
+        min = Math.min(r1, g1, b1);
+    const l = (max + min) / 2;
+
+    if (max === min) return [0, 0, l];
+
+    const d = max - min;
+    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    let h = 0;
+    if (max === r1) h = (g1 - b1) / d + (g1 < b1 ? 6 : 0);
+    else if (max === g1) h = (b1 - r1) / d + 2;
+    else h = (r1 - g1) / d + 4;
+
+    return [(h * 60 + 360) % 360, s, l];
+}
+
+function hslToRgb(h: number, s: number, l: number): [number, number, number] {
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+    const m = l - c / 2;
+    let r1 = 0,
+        g1 = 0,
+        b1 = 0;
+    if (h < 60) [r1, g1, b1] = [c, x, 0];
+    else if (h < 120) [r1, g1, b1] = [x, c, 0];
+    else if (h < 180) [r1, g1, b1] = [0, c, x];
+    else if (h < 240) [r1, g1, b1] = [0, x, c];
+    else if (h < 300) [r1, g1, b1] = [x, 0, c];
+    else [r1, g1, b1] = [c, 0, x];
+    return [Math.round((r1 + m) * 255), Math.round((g1 + m) * 255), Math.round((b1 + m) * 255)];
+}
+
+function format(r: number, g: number, b: number): PaletteColor {
+    const [h, s, l] = rgbToHsl(r, g, b);
+    return {
+        hex: `#${[r, g, b].map((x) => x.toString(16).padStart(2, '0')).join('')}`,
+        rgb: `rgb(${r}, ${g}, ${b})`,
+        hsl: `hsl(${h.toFixed(1)}, ${(s * 100).toFixed(1)}%, ${(l * 100).toFixed(1)}%)`,
+    };
+}
+
+function fromHueShifts(base: [number, number, number], shifts: number[]): PaletteColor[] {
+    const [h, s, l] = base;
+    return shifts.map((shift) => {
+        const newH = (h + shift + 360) % 360;
+        const [r, g, b] = hslToRgb(newH, s, l);
+        return format(r, g, b);
+    });
+}
+
+export default function palette(color: string, type: string): PaletteResult {
+    if (!color) throw new Error('A base color is required');
+    if (!type) throw new Error('A palette type is required');
+
+    const [r, g, b] = hexToRgb(color);
+    const base = format(r, g, b);
+    const hsl = rgbToHsl(r, g, b);
+
+    let colors: PaletteColor[];
+    switch (type) {
+        case 'complementary':
+            colors = fromHueShifts(hsl, [0, 180]);
+            break;
+        case 'triadic':
+            colors = fromHueShifts(hsl, [0, 120, 240]);
+            break;
+        case 'analogous':
+            colors = fromHueShifts(hsl, [-60, -30, 0, 30, 60]);
+            break;
+        case 'tetradic':
+            colors = fromHueShifts(hsl, [0, 90, 180, 270]);
+            break;
+        case 'split-complementary':
+            colors = fromHueShifts(hsl, [0, 150, 210]);
+            break;
+        default:
+            throw new Error('Type must be one of: complementary, triadic, analogous, tetradic, split-complementary');
+    }
+
+    return { base, type, colors };
+}

package/src/modules/v4/personal.ts

@@ -0,0 +1,147 @@
+import { random, randomNumber } from './utils.js';
+
+interface Person {
+    name: string;
+    social: string;
+    email: string;
+    country: string;
+}
+
+interface CountryInfo {
+    tel: string;
+    code: string;
+    lang: string;
+}
+
+export default function personal(): Record<string, unknown> {
+    const people: Person[] = [
+        { name: 'John Doe', social: 'john_doe', email: 'john@example.com', country: 'US' },
+        { name: 'Jane Martin', social: 'jane_martin', email: 'jane@example.com', country: 'FR' },
+        { name: 'Michael Johnson', social: 'mike_johnson', email: 'michael@example.com', country: 'UK' },
+        { name: 'Emily Davis', social: 'emily_davis', email: 'emily@example.com', country: 'ES' },
+        { name: 'Alexis Barbos', social: 'alexis_barbos', email: 'alexis@example.com', country: 'DE' },
+        { name: 'Sarah Williams', social: 'sarah_williams', email: 'sarah@example.com', country: 'IT' },
+        { name: 'Daniel Brown', social: 'daniel_brown', email: 'daniel@example.com', country: 'JP' },
+        { name: 'Sophia Wilson', social: 'sophia_wilson', email: 'sophia@example.com', country: 'BR' },
+        { name: 'James Taylor', social: 'james_taylor', email: 'james@example.com', country: 'CA' },
+        { name: 'Olivia Thomas', social: 'olivia_thomas', email: 'olivia@example.com', country: 'AU' },
+    ];
+
+    const countries: Record<string, CountryInfo> = {
+        US: { tel: '123-456-7890', code: '1', lang: 'English' },
+        FR: { tel: '06 78 90 12 34', code: '33', lang: 'French' },
+        UK: { tel: '7911 123456', code: '44', lang: 'English' },
+        ES: { tel: '678 901 234', code: '34', lang: 'Spanish' },
+        DE: { tel: '163 555 1584', code: '49', lang: 'German' },
+        IT: { tel: '345 678 9012', code: '39', lang: 'Italian' },
+        JP: { tel: '080-1234-5678', code: '81', lang: 'Japanese' },
+        BR: { tel: '(11) 98765-4321', code: '55', lang: 'Portuguese' },
+        CA: { tel: '416-123-4567', code: '1', lang: 'English' },
+        AU: { tel: '0412 345 678', code: '61', lang: 'English' },
+    };
+
+    const jobs = ['Writer', 'Artist', 'Musician', 'Explorer', 'Scientist', 'Engineer', 'Athlete', 'Doctor'];
+    const hobbies = ['Reading', 'Traveling', 'Gaming', 'Cooking', 'Fitness', 'Music', 'Photography', 'Writing'];
+    const cities = [
+        'New York',
+        'Paris',
+        'London',
+        'Madrid',
+        'Berlin',
+        'Rome',
+        'Tokyo',
+        'Los Angeles',
+        'Sydney',
+        'São Paulo',
+        'Toronto',
+    ];
+    const streets = ['Main St', '2nd Ave', 'Broadway', 'Park Lane', 'Elm St', 'Sunset Blvd', 'Maple St', 'Highland Rd'];
+
+    const card = Array.from({ length: 4 }, () => randomNumber(1000, 9999)).join(' ');
+    const cvc = randomNumber(100, 999);
+    const expiration = `${String(randomNumber(1, 12)).padStart(2, '0')}/${(new Date().getFullYear() + randomNumber(0, 3)).toString().slice(-2)}`;
+
+    const person = random(people);
+    const social = person.social;
+    const country = person.country;
+    const countryInfo = countries[country]!;
+    const phone = countryInfo.tel;
+    const lang = countryInfo.lang;
+
+    const age = randomNumber(18, 67);
+    const birthday = new Date(Date.now() - randomNumber(18, 67) * 365.25 * 24 * 60 * 60 * 1000).toISOString();
+
+    const emergencyContacts: { name: string; relationship: string; phone: string }[] = [];
+    const yearIncome = randomNumber(20000, 100000);
+    const subscriptions: string[] = [];
+    const pets: string[] = [];
+    const vehicles: string[] = [];
+    let civilStatus = 'Single';
+    let children = 0;
+
+    if (age >= 21 && Math.random() > 0.7) civilStatus = 'Married';
+    if (civilStatus === 'Married' && age >= 25) children = randomNumber(0, 3);
+
+    while (emergencyContacts.length < randomNumber(1, 3)) {
+        let emergencyContact = random(people);
+        while (
+            emergencyContact.email === person.email ||
+            emergencyContacts.some((e) => e.name === emergencyContact.name)
+        ) {
+            emergencyContact = random(people);
+        }
+        const emergencyPhone = `${randomNumber(100, 999)}-${randomNumber(100, 999)}-${randomNumber(1000, 9999)}`;
+        emergencyContacts.push({
+            name: emergencyContact.name,
+            relationship: random(['Spouse', 'Parent', 'Sibling', 'Friend']),
+            phone: `+${countryInfo.code} ${emergencyPhone}`,
+        });
+    }
+
+    while (subscriptions.length < randomNumber(1, 3)) {
+        const subscription = random(['Netflix', 'Spotify', 'Amazon Prime', 'Disney+', 'Hulu']);
+        if (!subscriptions.includes(subscription)) subscriptions.push(subscription);
+    }
+
+    while (pets.length < randomNumber(1, 3)) {
+        const pet = random(['Dog', 'Cat', 'Fish', 'Bird', 'None']);
+        if (!pets.includes(pet)) pets.push(pet);
+    }
+
+    while (vehicles.length < randomNumber(1, 3)) {
+        const vehicle = random(['Car', 'Bike', 'Motorcycle', 'Bus', 'None']);
+        if (!vehicles.includes(vehicle)) vehicles.push(vehicle);
+    }
+
+    return {
+        name: person.name,
+        email: person.email,
+        localisation: country,
+        phone: `+${countryInfo.code} ${phone}`,
+        job: random(jobs),
+        hobbies: random(hobbies),
+        language: lang,
+        card,
+        cvc,
+        expiration,
+        address: `${randomNumber(1, 9999)} ${random(streets)}, ${random(cities)}`,
+        birthday,
+        civil_status: civilStatus,
+        children,
+        vehicle: vehicles,
+        social_profiles: {
+            twitter: `@${social}`,
+            facebook: `facebook.com/${social}`,
+            linkedin: `linkedin.com/in/${social}`,
+            instagram: `instagram.com/${social}`,
+        },
+        year_income: `${yearIncome} USD/year`,
+        month_income: `${(yearIncome / 12).toFixed(2)} USD/month`,
+        education: random(['High School', "Bachelor's", "Master's", 'PhD']),
+        work_experience: `${randomNumber(0, 20)} years`,
+        health_status: random(['Healthy', 'Minor Issues', 'Chronic Conditions']),
+        emergency_contacts: emergencyContacts,
+        subscriptions,
+        pets,
+    };
+}