@20syldev/api 4.0.0 → 4.2.0

package/tests/unit/dice.test.ts

@@ -0,0 +1,57 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+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

@@ -0,0 +1,47 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+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

@@ -0,0 +1,108 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    base64encode,
+    base64decode,
+    urlencode,
+    urldecode,
+    morse,
+    unmorse,
+    rot13,
+    caesar,
+    binary,
+    unbinary,
+} 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/hash.test.ts

@@ -0,0 +1,37 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+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',
+        });
+    });
+
+    test('md5 of "hello"', () => {
+        const result = hash('hello', 'md5');
+        assert.deepEqual(result, {
+            method: 'md5',
+            hash: '5d41402abc4b2a76b9719d911017c592',
+        });
+    });
+
+    test('sha1 of empty string', () => {
+        const result = hash('', 'sha1');
+        assert.equal((result as { hash: string }).hash, 'da39a3ee5e6b4b0d3255bfef95601890afd80709');
+    });
+
+    test('returns error object on unsupported method', () => {
+        const result = hash('hello', 'fakehash');
+        assert.ok('error' in result);
+    });
+
+    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

@@ -0,0 +1,77 @@
+import { test, describe, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+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);
+    });
+});
+
+before(() => {
+    globalThis.fetch = ORIGINAL_FETCH;
+});

package/tests/unit/levenshtein.test.ts

@@ -0,0 +1,34 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+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/personal.test.ts

@@ -0,0 +1,65 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import personal from '../../src/modules/v4/personal.js';
+
+describe('personal', () => {
+    test('returns expected fields', () => {
+        const result = personal();
+        const fields = [
+            'name',
+            'email',
+            'phone',
+            'job',
+            'language',
+            'card',
+            'cvc',
+            'expiration',
+            'address',
+            'birthday',
+            'civil_status',
+            'social_profiles',
+            'emergency_contacts',
+            'subscriptions',
+            'pets',
+        ];
+        for (const f of fields) {
+            assert.ok(f in result, `missing field: ${f}`);
+        }
+    });
+
+    test('card has 4 groups of 4 digits', () => {
+        const result = personal();
+        assert.match(result.card as string, /^\d{4} \d{4} \d{4} \d{4}$/);
+    });
+
+    test('cvc is 3 digits', () => {
+        const result = personal();
+        const cvc = result.cvc as number;
+        assert.ok(cvc >= 100 && cvc <= 999);
+    });
+
+    test('expiration MM/YY format', () => {
+        const result = personal();
+        assert.match(result.expiration as string, /^\d{2}\/\d{2}$/);
+    });
+
+    test('phone has international code', () => {
+        const result = personal();
+        assert.match(result.phone as string, /^\+\d+ /);
+    });
+
+    test('social_profiles has 4 platforms', () => {
+        const result = personal();
+        const social = result.social_profiles as Record<string, string>;
+        assert.ok('twitter' in social);
+        assert.ok('facebook' in social);
+        assert.ok('linkedin' in social);
+        assert.ok('instagram' in social);
+    });
+
+    test('emergency_contacts non-empty', () => {
+        const result = personal();
+        const contacts = result.emergency_contacts as unknown[];
+        assert.ok(contacts.length >= 1);
+    });
+});

package/tests/unit/statistics.test.ts

@@ -0,0 +1,57 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import statistics from '../../src/modules/v4/statistics.js';
+
+describe('statistics', () => {
+    test('basic computation on integers', () => {
+        const result = statistics('1,2,3,4,5');
+        assert.equal(result.count, 5);
+        assert.equal(result.sum, 15);
+        assert.equal(result.min, 1);
+        assert.equal(result.max, 5);
+        assert.equal(result.range, 4);
+        assert.equal(result.mean, 3);
+        assert.equal(result.median, 3);
+    });
+
+    test('median on even count', () => {
+        const result = statistics('1,2,3,4');
+        assert.equal(result.median, 2.5);
+    });
+
+    test('mode is empty when all values unique', () => {
+        const result = statistics('1,2,3,4,5');
+        assert.deepEqual(result.mode, []);
+    });
+
+    test('mode detects most frequent value', () => {
+        const result = statistics('1,2,2,3,3,3');
+        assert.deepEqual(result.mode, [3]);
+    });
+
+    test('multiple modes', () => {
+        const result = statistics('1,1,2,2,3');
+        assert.deepEqual(result.mode.sort(), [1, 2]);
+    });
+
+    test('stddev of identical values is 0', () => {
+        const result = statistics('5,5,5,5');
+        assert.equal(result.stddev, 0);
+        assert.equal(result.variance, 0);
+    });
+
+    test('handles negative and decimal values', () => {
+        const result = statistics('-1.5,0,1.5');
+        assert.equal(result.mean, 0);
+        assert.equal(result.min, -1.5);
+        assert.equal(result.max, 1.5);
+    });
+
+    test('throws on non-numeric values', () => {
+        assert.throws(() => statistics('1,abc,3'), /must contain only numbers/);
+    });
+
+    test('throws on missing values', () => {
+        assert.throws(() => statistics(''), /required/);
+    });
+});

package/tests/unit/text.test.ts

@@ -0,0 +1,107 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { slug, stats, lorem, number } from '../../src/modules/v4/text.js';
+
+describe('text', () => {
+    describe('slug', () => {
+        test('basic slug', () => {
+            assert.equal(slug('Hello World'), 'hello-world');
+        });
+
+        test('strips diacritics', () => {
+            assert.equal(slug('Crème Brûlée'), 'creme-brulee');
+        });
+
+        test('strips special chars', () => {
+            assert.equal(slug('Mon Article #1 !'), 'mon-article-1');
+        });
+
+        test('collapses multiple spaces', () => {
+            assert.equal(slug('a   b   c'), 'a-b-c');
+        });
+    });
+
+    describe('stats', () => {
+        test('counts characters and words', () => {
+            const result = stats('Hello world');
+            assert.equal(result.characters, 11);
+            assert.equal(result.charactersNoSpaces, 10);
+            assert.equal(result.words, 2);
+        });
+
+        test('counts sentences', () => {
+            const result = stats('Hi. How are you? Fine!');
+            assert.equal(result.sentences, 3);
+        });
+
+        test('reading time format', () => {
+            const result = stats('a '.repeat(200).trim());
+            assert.match(result.readingTime, /min/);
+        });
+
+        test('short text returns seconds', () => {
+            const result = stats('hello world');
+            assert.match(result.readingTime, /s$/);
+        });
+    });
+
+    describe('lorem', () => {
+        test('words count', () => {
+            const result = lorem('words', '10');
+            assert.equal(result.split(' ').length, 10);
+        });
+
+        test('sentences end with period', () => {
+            const result = lorem('sentences', '3');
+            const sentences = result.split('. ');
+            assert.equal(sentences.length, 3);
+        });
+
+        test('paragraphs separated by double newline', () => {
+            const result = lorem('paragraphs', '2');
+            assert.equal(result.split('\n\n').length, 2);
+        });
+
+        test('throws on invalid type', () => {
+            assert.throws(() => lorem('verses', '5'), /Type must be one of/);
+        });
+    });
+
+    describe('number', () => {
+        test('English: 42', () => {
+            assert.equal(number('42', 'en'), 'forty-two');
+        });
+
+        test('English: 100', () => {
+            assert.equal(number('100', 'en'), 'one hundred');
+        });
+
+        test('English: 1234', () => {
+            assert.equal(number('1234', 'en'), 'one thousand two hundred thirty-four');
+        });
+
+        test('French: 21', () => {
+            assert.equal(number('21', 'fr'), 'vingt et un');
+        });
+
+        test('French: 80', () => {
+            assert.equal(number('80', 'fr'), 'quatre-vingts');
+        });
+
+        test('French: 0', () => {
+            assert.equal(number('0', 'fr'), 'zéro');
+        });
+
+        test('English: negative', () => {
+            assert.equal(number('-5', 'en'), 'minus five');
+        });
+
+        test('throws on invalid lang', () => {
+            assert.throws(() => number('42', 'es'), /Lang must be one of/);
+        });
+
+        test('throws on non-integer', () => {
+            assert.throws(() => number('3.14', 'en'), /must be an integer/);
+        });
+    });
+});

package/tests/unit/time.test.ts

@@ -0,0 +1,67 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import time from '../../src/modules/v4/time.js';
+
+describe('time', () => {
+    test('live returns full set of formats', () => {
+        const result = time('live');
+        const fields = [
+            'iso',
+            'utc',
+            'timestamp',
+            'locale',
+            'date',
+            'time',
+            'year',
+            'month',
+            'day',
+            'hour',
+            'minute',
+            'second',
+            'ms',
+            'dayOfWeek',
+            'dayOfYear',
+            'weekNumber',
+            'timezone',
+            'timezoneOffset',
+        ];
+        for (const f of fields) {
+            assert.ok(f in result, `missing field: ${f}`);
+        }
+    });
+
+    test('iso is parseable', () => {
+        const result = time('live');
+        assert.ok(!isNaN(Date.parse(result.iso as string)));
+    });
+
+    test('format=year returns only date', () => {
+        const result = time('live', undefined, undefined, 'year');
+        assert.ok('date' in result);
+        assert.equal(typeof result.date, 'number');
+    });
+
+    test('random within range', () => {
+        const result = time('random', '2020-01-01', '2020-12-31');
+        const ts = result.timestamp as number;
+        assert.ok(ts >= new Date('2020-01-01').getTime());
+        assert.ok(ts <= new Date('2020-12-31').getTime());
+    });
+
+    test('throws on invalid type', () => {
+        assert.throws(() => time('foo'), /valid type/);
+    });
+
+    test('throws on invalid format', () => {
+        assert.throws(() => time('live', undefined, undefined, 'fakeformat'), /valid format/);
+    });
+
+    test('throws on invalid timezone', () => {
+        assert.throws(() => time('live', undefined, undefined, undefined, 'Mars/Olympus'), /valid timezone/);
+    });
+
+    test('Europe/Paris timezone', () => {
+        const result = time('live', undefined, undefined, undefined, 'Europe/Paris');
+        assert.equal(result.timezone, 'Europe/Paris');
+    });
+});