@20syldev/api 4.8.0 → 5.0.0

package/tests/unit/dice.test.ts

@@ -1,58 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import dice from '../../src/modules/v4/dice.js';
-
-describe('dice', () => {
-    test('parses 2d6+3 notation', () => {
-        const result = dice('2d6+3');
-        assert.equal(result.count, 2);
-        assert.equal(result.sides, 6);
-        assert.equal(result.modifier, 3);
-        assert.equal(result.results.length, 2);
-    });
-
-    test('total includes positive modifier', () => {
-        const result = dice('1d2+10');
-        assert.equal(result.modifier, 10);
-        assert.ok(result.total === 11 || result.total === 12);
-    });
-
-    test('negative modifier', () => {
-        const result = dice('1d2-5');
-        assert.equal(result.modifier, -5);
-        assert.ok(result.total === -4 || result.total === -3);
-    });
-
-    test('default count of 1 when omitted', () => {
-        const result = dice('d20');
-        assert.equal(result.count, 1);
-        assert.equal(result.sides, 20);
-    });
-
-    test('all results are within 1..sides', () => {
-        for (let i = 0; i < 50; i++) {
-            const result = dice('5d10');
-            for (const r of result.results) {
-                assert.ok(r >= 1 && r <= 10, `result ${r} out of range`);
-            }
-        }
-    });
-
-    test('handles space instead of +', () => {
-        const result = dice('2d6 3');
-        assert.equal(result.modifier, 3);
-    });
-
-    test('throws on invalid notation', () => {
-        assert.throws(() => dice('2x6'), /Invalid notation/);
-    });
-
-    test('throws on too many dice', () => {
-        assert.throws(() => dice('200d6'), /between 1 and 100/);
-    });
-
-    test('throws on invalid sides', () => {
-        assert.throws(() => dice('2d1'), /between 2 and 1000/);
-    });
-});

package/tests/unit/domain.test.ts

@@ -1,48 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import domain from '../../src/modules/v4/domain.js';
-
-describe('domain', () => {
-    test('returns expected fields', () => {
-        const result = domain();
-        assert.ok('domain' in result);
-        assert.ok('full_domain' in result);
-        assert.ok('ip_address' in result);
-        assert.ok('dns_servers' in result);
-        assert.ok('country' in result);
-    });
-
-    test('domain has TLD', () => {
-        const result = domain();
-        assert.match(
-            result.domain as string,
-            /\.(com|fr|eu|dev|net|org|io|tech|biz|info|co|app|store|online|shop|tv)$/,
-        );
-    });
-
-    test('full_domain starts with subdomain', () => {
-        const result = domain();
-        const full = result.full_domain as string;
-        const dom = result.domain as string;
-        assert.ok(full.endsWith(dom));
-    });
-
-    test('ip_address is non-empty array', () => {
-        const result = domain();
-        const ips = result.ip_address as string[];
-        assert.ok(Array.isArray(ips));
-        assert.ok(ips.length >= 1);
-    });
-
-    test('seo_score in range 0..99', () => {
-        const result = domain();
-        const score = result.seo_score as number;
-        assert.ok(score >= 0 && score < 100);
-    });
-
-    test('ssl_certified is boolean', () => {
-        const result = domain();
-        assert.equal(typeof result.ssl_certified, 'boolean');
-    });
-});

package/tests/unit/encode.test.ts

@@ -1,109 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import {
-    base64decode,
-    base64encode,
-    binary,
-    caesar,
-    morse,
-    rot13,
-    unbinary,
-    unmorse,
-    urldecode,
-    urlencode,
-} from '../../src/modules/v4/encode.js';
-
-describe('encode', () => {
-    describe('base64', () => {
-        test('encodes ASCII text', () => {
-            assert.equal(base64encode('hello'), 'aGVsbG8=');
-        });
-
-        test('round-trip preserves UTF-8', () => {
-            assert.equal(base64decode(base64encode('héllo wörld')), 'héllo wörld');
-        });
-
-        test('decode rejects invalid base64', () => {
-            assert.throws(() => base64decode('not!valid'), /Invalid Base64/);
-        });
-    });
-
-    describe('url', () => {
-        test('encodes special chars', () => {
-            assert.equal(urlencode('a b&c=d'), 'a%20b%26c%3Dd');
-        });
-
-        test('round-trip', () => {
-            assert.equal(urldecode(urlencode('hello world?')), 'hello world?');
-        });
-
-        test('decode rejects malformed sequence', () => {
-            assert.throws(() => urldecode('%ZZ'), /Invalid URL/);
-        });
-    });
-
-    describe('morse', () => {
-        test('encodes SOS', () => {
-            assert.equal(morse('SOS'), '... --- ...');
-        });
-
-        test('round-trip with words', () => {
-            assert.equal(unmorse(morse('HELLO WORLD')), 'HELLO WORLD');
-        });
-
-        test('throws on unsupported char', () => {
-            assert.throws(() => morse('hello#'), /Unsupported character/);
-        });
-    });
-
-    describe('rot13', () => {
-        test('shifts letters by 13', () => {
-            assert.equal(rot13('Hello'), 'Uryyb');
-        });
-
-        test('is its own inverse', () => {
-            assert.equal(rot13(rot13('The Quick Brown Fox')), 'The Quick Brown Fox');
-        });
-
-        test('preserves non-alpha chars', () => {
-            assert.equal(rot13('abc 123!'), 'nop 123!');
-        });
-    });
-
-    describe('caesar', () => {
-        test('shift 3 forward', () => {
-            assert.equal(caesar('abc', '3'), 'def');
-        });
-
-        test('shift wraps around alphabet', () => {
-            assert.equal(caesar('xyz', '3'), 'abc');
-        });
-
-        test('negative shift', () => {
-            assert.equal(caesar('def', '-3'), 'abc');
-        });
-
-        test('throws on non-numeric shift', () => {
-            assert.throws(() => caesar('abc', 'abc'), /Shift must be a number/);
-        });
-    });
-
-    describe('binary', () => {
-        test('encodes A as 01000001', () => {
-            assert.equal(binary('A'), '01000001');
-        });
-
-        test('round-trip', () => {
-            assert.equal(unbinary(binary('Hello!')), 'Hello!');
-        });
-
-        test('rejects malformed binary', () => {
-            assert.throws(() => unbinary('012'), /Invalid binary/);
-        });
-
-        test('rejects wrong group size', () => {
-            assert.throws(() => unbinary('0100'), /Each binary group must contain 8 bits/);
-        });
-    });
-});

package/tests/unit/geo.test.ts

@@ -1,46 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import geo from '../../src/modules/v4/geo.js';
-
-describe('geo', () => {
-    test('Paris to NYC distance ~5837 km', () => {
-        const result = geo('48.8566', '2.3522', '40.7128', '-74.006');
-        assert.ok(Math.abs(result.distance.km - 5837) < 50, `expected ~5837, got ${result.distance.km}`);
-    });
-
-    test('same point returns 0 km', () => {
-        const result = geo('48.8566', '2.3522', '48.8566', '2.3522');
-        assert.equal(result.distance.km, 0);
-    });
-
-    test('miles and nautical miles match km conversion', () => {
-        const result = geo('0', '0', '0', '90');
-        assert.ok(Math.abs(result.distance.miles - result.distance.km * 0.621371) < 0.01);
-        assert.ok(Math.abs(result.distance.nauticalMiles - result.distance.km * 0.539957) < 0.01);
-    });
-
-    test('bearing N for due north', () => {
-        const result = geo('0', '0', '10', '0');
-        assert.equal(result.bearing.degrees, 0);
-        assert.equal(result.bearing.cardinal, 'N');
-    });
-
-    test('bearing E for due east', () => {
-        const result = geo('0', '0', '0', '10');
-        assert.equal(result.bearing.degrees, 90);
-        assert.equal(result.bearing.cardinal, 'E');
-    });
-
-    test('throws on invalid latitude', () => {
-        assert.throws(() => geo('100', '0', '0', '0'), /lat1 must be between/);
-    });
-
-    test('throws on invalid longitude', () => {
-        assert.throws(() => geo('0', '200', '0', '0'), /lon1 must be between/);
-    });
-
-    test('throws on non-numeric coords', () => {
-        assert.throws(() => geo('abc', '0', '0', '0'), /must be a number/);
-    });
-});

package/tests/unit/hash.test.ts

@@ -1,45 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import hash from '../../src/modules/v4/hash.js';
-
-describe('hash', () => {
-    test('sha256 of "hello"', () => {
-        const result = hash('hello', 'sha256');
-        assert.deepEqual(result, {
-            method: 'sha256',
-            hash: '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-            encoding: 'hex',
-        });
-    });
-
-    test('md5 of "hello"', () => {
-        const result = hash('hello', 'md5');
-        assert.equal(result.hash, '5d41402abc4b2a76b9719d911017c592');
-        assert.equal(result.encoding, 'hex');
-    });
-
-    test('base64 encoding', () => {
-        const result = hash('hello', 'sha256', 'base64');
-        assert.equal(result.encoding, 'base64');
-        assert.ok(result.hash.length > 0);
-    });
-
-    test('throws on empty text', () => {
-        assert.throws(() => hash('', 'sha256'), /Text is required/);
-    });
-
-    test('throws on unsupported method', () => {
-        assert.throws(() => hash('hello', 'fakehash'), /Unsupported method/);
-    });
-
-    test('throws on invalid encoding', () => {
-        assert.throws(() => hash('hello', 'sha256', 'utf8'), /Encoding must be/);
-    });
-
-    test('same input + method = same hash (deterministic)', () => {
-        const a = hash('test', 'sha256');
-        const b = hash('test', 'sha256');
-        assert.deepEqual(a, b);
-    });
-});

package/tests/unit/hyperplanning.test.ts

@@ -1,97 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { after, before, describe, test } from 'node:test';
-
-import hyperplanning from '../../src/modules/v4/hyperplanning.js';
-
-const ORIGINAL_FETCH = globalThis.fetch;
-
-const sampleIcs = `BEGIN:VCALENDAR
-VERSION:2.0
-PRODID:-//Test//Test//EN
-BEGIN:VEVENT
-UID:event-1@test
-DTSTAMP:20990101T000000Z
-DTSTART:20990101T080000Z
-DTEND:20990101T090000Z
-SUMMARY:Mathematics - CM
-DESCRIPTION:Matière : Mathematics\\nEnseignant : Mr Smith\\nPromotions : G1, G2\\nSalle : Room 101
-END:VEVENT
-END:VCALENDAR`;
-
-function mockFetch(body: string, ok = true, contentType = 'text/calendar'): void {
-    globalThis.fetch = (async () => ({
-        ok,
-        headers: { get: (h: string) => (h.toLowerCase() === 'content-type' ? contentType : null) },
-        text: async () => body,
-    })) as unknown as typeof fetch;
-}
-
-describe('hyperplanning', () => {
-    after(() => {
-        globalThis.fetch = ORIGINAL_FETCH;
-    });
-
-    test('parses valid ICS with default detail', async () => {
-        mockFetch(sampleIcs);
-        const events = await hyperplanning('https://fake.test/cal.ics');
-        assert.equal(events.length, 1);
-        assert.equal(events[0]!.summary, 'Mathematics - CM');
-        assert.ok(events[0]!.start);
-        assert.ok(events[0]!.end);
-    });
-
-    test('detail=list returns split summary', async () => {
-        mockFetch(sampleIcs);
-        const events = await hyperplanning('https://fake.test/cal.ics', 'list');
-        assert.deepEqual(events[0]!.summary, ['Mathematics', 'CM']);
-    });
-
-    test('detail=full extracts subject/teacher/classes', async () => {
-        mockFetch(sampleIcs);
-        const events = await hyperplanning('https://fake.test/cal.ics', 'full');
-        const e = events[0]!;
-        assert.equal(e.subject, 'Mathematics');
-        assert.equal(e.teacher, 'Mr Smith');
-        assert.deepEqual(e.classes, ['G1', 'G2']);
-    });
-
-    test('throws on non-OK response', async () => {
-        mockFetch('', false);
-        await assert.rejects(() => hyperplanning('https://fake.test/cal.ics'), /Invalid ICS/);
-    });
-
-    test('throws on wrong content-type', async () => {
-        mockFetch(sampleIcs, true, 'text/html');
-        await assert.rejects(() => hyperplanning('https://fake.test/cal.ics'), /Invalid ICS/);
-    });
-
-    test('filters out past events', async () => {
-        const pastIcs = sampleIcs.replaceAll('20990101', '19990101');
-        mockFetch(pastIcs);
-        const events = await hyperplanning('https://fake.test/cal.ics');
-        assert.equal(events.length, 0);
-    });
-
-    test('throws on HTTP URL', async () => {
-        await assert.rejects(() => hyperplanning('http://fake.test/cal.ics'), /Only HTTPS/);
-    });
-
-    test('throws on private IP', async () => {
-        await assert.rejects(() => hyperplanning('https://127.0.0.1/cal.ics'), /private/);
-        await assert.rejects(() => hyperplanning('https://192.168.1.1/cal.ics'), /private/);
-        await assert.rejects(() => hyperplanning('https://10.0.0.1/cal.ics'), /private/);
-        await assert.rejects(() => hyperplanning('https://169.254.169.254/latest'), /private/);
-    });
-
-    test('throws on localhost', async () => {
-        await assert.rejects(() => hyperplanning('https://localhost/cal.ics'), /private/);
-    });
-
-    test('throws on invalid URL', async () => {
-        await assert.rejects(() => hyperplanning('not-a-url'), /Invalid URL/);
-    });
-});
-
-before(() => {
-    globalThis.fetch = ORIGINAL_FETCH;
-});

package/tests/unit/ip.test.ts

@@ -1,140 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import ip from '../../src/modules/v4/ip.js';
-
-describe('ip', () => {
-    describe('IPv4 — type detection', () => {
-        test('public IP returns public type and class A', () => {
-            const result = ip('8.8.8.8');
-            assert.equal(result.version, 'IPv4');
-            assert.equal(result.type, 'public');
-            assert.equal(result.class, 'A');
-        });
-
-        test('private 10.x.x.x', () => {
-            const result = ip('10.0.0.1');
-            assert.equal(result.type, 'private');
-            assert.equal(result.range, '10.0.0.0/8');
-        });
-
-        test('private 172.16-31.x.x', () => {
-            const result = ip('172.16.0.1');
-            assert.equal(result.type, 'private');
-            assert.equal(result.range, '172.16.0.0/12');
-        });
-
-        test('private 192.168.x.x', () => {
-            const result = ip('192.168.1.1');
-            assert.equal(result.type, 'private');
-            assert.equal(result.class, 'C');
-            assert.equal(result.range, '192.168.0.0/16');
-        });
-
-        test('loopback 127.0.0.1', () => {
-            const result = ip('127.0.0.1');
-            assert.equal(result.type, 'loopback');
-            assert.equal(result.range, '127.0.0.0/8');
-        });
-
-        test('link-local 169.254.x.x', () => {
-            const result = ip('169.254.1.1');
-            assert.equal(result.type, 'link-local');
-        });
-
-        test('multicast 224.x.x.x', () => {
-            const result = ip('224.0.0.1');
-            assert.equal(result.type, 'multicast');
-        });
-
-        test('broadcast 255.255.255.255', () => {
-            const result = ip('255.255.255.255');
-            assert.equal(result.type, 'broadcast');
-            assert.equal(result.class, 'E');
-        });
-    });
-
-    describe('IPv4 — representations', () => {
-        test('binary of 192.168.1.1', () => {
-            const result = ip('192.168.1.1');
-            assert.equal(result.binary, '11000000.10101000.00000001.00000001');
-        });
-
-        test('decimal of 192.168.1.1', () => {
-            const result = ip('192.168.1.1');
-            assert.equal(result.decimal, 3232235777);
-        });
-
-        test('decimal of 8.8.8.8', () => {
-            const result = ip('8.8.8.8');
-            assert.equal(result.decimal, 134744072);
-        });
-
-        test('reverse DNS of 192.168.1.1', () => {
-            const result = ip('192.168.1.1');
-            assert.equal(result.reverse, '1.1.168.192.in-addr.arpa');
-        });
-
-        test('class B for 128.x', () => {
-            assert.equal(ip('128.0.0.1').class, 'B');
-        });
-
-        test('class C for 192.x (non-private)', () => {
-            assert.equal(ip('200.0.0.1').class, 'C');
-        });
-    });
-
-    describe('IPv6', () => {
-        test('loopback ::1', () => {
-            const result = ip('::1');
-            assert.equal(result.version, 'IPv6');
-            assert.equal(result.type, 'loopback');
-            assert.equal(result.range, '::1/128');
-        });
-
-        test('link-local fe80::1', () => {
-            const result = ip('fe80::1');
-            assert.equal(result.type, 'link-local');
-            assert.equal(result.range, 'fe80::/10');
-        });
-
-        test('unique-local fc00::1', () => {
-            const result = ip('fc00::1');
-            assert.equal(result.type, 'private');
-            assert.equal(result.range, 'fc00::/7');
-        });
-
-        test('multicast ff02::1', () => {
-            const result = ip('ff02::1');
-            assert.equal(result.type, 'multicast');
-        });
-
-        test(':: expansion produces 8 groups', () => {
-            const result = ip('::1');
-            assert.equal(result.ip.split(':').length, 8);
-        });
-
-        test('reverse DNS ends in .ip6.arpa', () => {
-            const result = ip('::1');
-            assert.ok(result.reverse.endsWith('.ip6.arpa'));
-        });
-    });
-
-    describe('errors', () => {
-        test('throws on empty string', () => {
-            assert.throws(() => ip(''), /required/);
-        });
-
-        test('throws on invalid IPv4 octet > 255', () => {
-            assert.throws(() => ip('256.0.0.1'), /Invalid IPv4/);
-        });
-
-        test('throws on incomplete IPv4', () => {
-            assert.throws(() => ip('192.168.1'), /Invalid IPv4/);
-        });
-
-        test('throws on plain string', () => {
-            assert.throws(() => ip('notanip'), /Invalid IP address format/);
-        });
-    });
-});

package/tests/unit/levenshtein.test.ts

@@ -1,35 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import levenshtein from '../../src/modules/v4/levenshtein.js';
-
-describe('levenshtein', () => {
-    test('identical strings: distance 0', () => {
-        const result = levenshtein('hello', 'hello');
-        assert.equal(result.distance, 0);
-    });
-
-    test('kitten / sitting: distance 3', () => {
-        const result = levenshtein('kitten', 'sitting');
-        assert.equal(result.distance, 3);
-    });
-
-    test('saturday / sunday: distance 3', () => {
-        const result = levenshtein('saturday', 'sunday');
-        assert.equal(result.distance, 3);
-    });
-
-    test('empty vs string: distance = string length', () => {
-        const result = levenshtein('a', 'abc');
-        assert.equal(result.distance, 2);
-    });
-
-    test('throws on missing first string', () => {
-        assert.throws(() => levenshtein('', 'abc'), /first string/);
-    });
-
-    test('throws on string > 1000 chars', () => {
-        const big = 'a'.repeat(1001);
-        assert.throws(() => levenshtein(big, 'b'), /1000/);
-    });
-});

package/tests/unit/palette.test.ts

@@ -1,54 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import palette from '../../src/modules/v4/palette.js';
-
-describe('palette', () => {
-    test('complementary returns 2 colors', () => {
-        const result = palette('#ff6600', 'complementary');
-        assert.equal(result.colors.length, 2);
-        assert.equal(result.type, 'complementary');
-    });
-
-    test('triadic returns 3 colors', () => {
-        const result = palette('#ff6600', 'triadic');
-        assert.equal(result.colors.length, 3);
-    });
-
-    test('analogous returns 5 colors', () => {
-        const result = palette('#ff6600', 'analogous');
-        assert.equal(result.colors.length, 5);
-    });
-
-    test('tetradic returns 4 colors', () => {
-        const result = palette('#0066ff', 'tetradic');
-        assert.equal(result.colors.length, 4);
-    });
-
-    test('split-complementary returns 3 colors', () => {
-        const result = palette('#0066ff', 'split-complementary');
-        assert.equal(result.colors.length, 3);
-    });
-
-    test('each color has hex/rgb/hsl', () => {
-        const result = palette('#ff6600', 'triadic');
-        for (const c of result.colors) {
-            assert.match(c.hex, /^#[0-9a-f]{6}$/);
-            assert.match(c.rgb, /^rgb\(/);
-            assert.match(c.hsl, /^hsl\(/);
-        }
-    });
-
-    test('base color is included', () => {
-        const result = palette('#ff6600', 'complementary');
-        assert.equal(result.base.hex, '#ff6600');
-    });
-
-    test('throws on invalid hex', () => {
-        assert.throws(() => palette('#zzz', 'triadic'), /Invalid HEX/);
-    });
-
-    test('throws on unknown type', () => {
-        assert.throws(() => palette('#ff6600', 'rainbow'), /must be one of/);
-    });
-});