@20syldev/api 4.8.0 → 5.0.0

package/tests/unit/password.test.ts

@@ -1,86 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import password from '../../src/modules/v4/password.js';
-
-describe('password', () => {
-    describe('random mode', () => {
-        test('default returns one password of length 16', () => {
-            const r = password();
-            assert.equal(r.passwords.length, 1);
-            assert.equal(r.passwords[0]!.length, 16);
-            assert.equal(r.type, 'random');
-            assert.equal(r.length, 16);
-        });
-
-        test('length is respected', () => {
-            const r = password('random', 32);
-            assert.equal(r.passwords[0]!.length, 32);
-        });
-
-        test('no symbols when symbols=false', () => {
-            const r = password('random', 64, { symbols: false });
-            assert.ok(!/[!@#$%^&*()\-_=+[\]{}|;:,.<>?]/.test(r.passwords[0]!));
-        });
-
-        test('only digits when only digits enabled', () => {
-            const r = password('random', 16, { uppercase: false, lowercase: false, digits: true, symbols: false });
-            assert.ok(/^\d+$/.test(r.passwords[0]!));
-        });
-
-        test('exclude chars are absent from password', () => {
-            const r = password('random', 64, { exclude: 'aeiou' });
-            assert.ok(!/[aeiou]/.test(r.passwords[0]!));
-        });
-
-        test('count=5 returns 5 passwords', () => {
-            const r = password('random', 16, { count: 5 });
-            assert.equal(r.passwords.length, 5);
-        });
-
-        test('entropy and strength are present', () => {
-            const r = password();
-            assert.ok(typeof r.entropy === 'number');
-            assert.ok(['weak', 'moderate', 'strong', 'very_strong'].includes(r.strength));
-        });
-    });
-
-    describe('passphrase mode', () => {
-        test('returns words joined by separator', () => {
-            const r = password('passphrase', 4, { separator: '-' });
-            assert.equal(r.type, 'passphrase');
-            const words = r.passwords[0]!.split('-');
-            assert.equal(words.length, 4);
-        });
-
-        test('custom separator is used', () => {
-            const r = password('passphrase', 3, { separator: '.' });
-            assert.ok(r.passwords[0]!.includes('.'));
-        });
-    });
-
-    describe('errors', () => {
-        test('length below 8 throws', () => {
-            assert.throws(() => password('random', 4), /Length must be between/);
-        });
-
-        test('length above 128 throws', () => {
-            assert.throws(() => password('random', 200), /Length must be between/);
-        });
-
-        test('no charset active throws', () => {
-            assert.throws(
-                () => password('random', 16, { uppercase: false, lowercase: false, digits: false, symbols: false }),
-                /At least one character set/,
-            );
-        });
-
-        test('count above 20 throws', () => {
-            assert.throws(() => password('random', 16, { count: 21 }), /Count must be between/);
-        });
-
-        test('invalid type throws', () => {
-            assert.throws(() => password('invalid'), /Type must be/);
-        });
-    });
-});

package/tests/unit/personal.test.ts

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

@@ -1,58 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import placeholder from '../../src/modules/v4/placeholder.js';
-
-describe('placeholder', () => {
-    test('image returns SVG with text', () => {
-        const result = placeholder('image', { width: '200', height: '100', text: 'Hello' });
-        assert.equal(result.type, 'image');
-        assert.equal(result.contentType, 'image/svg+xml');
-        assert.match(result.body, /<svg/);
-        assert.match(result.body, /Hello/);
-    });
-
-    test('skeleton returns SVG with animation', () => {
-        const result = placeholder('skeleton', { width: '300', height: '200' });
-        assert.equal(result.type, 'skeleton');
-        assert.equal(result.contentType, 'image/svg+xml');
-        assert.match(result.body, /<svg/);
-    });
-
-    test('default dimensions 800x600', () => {
-        const result = placeholder('image', {});
-        assert.match(result.body, /width="800"/);
-        assert.match(result.body, /height="600"/);
-    });
-
-    test('skeleton with avatar', () => {
-        const result = placeholder('skeleton', { avatar: 'circle' });
-        assert.match(result.body, /<circle/);
-    });
-
-    test('skeleton with rows', () => {
-        const result = placeholder('skeleton', { rows: '5' });
-        assert.match(result.body, /<rect/);
-    });
-
-    test('animate none removes animation', () => {
-        const result = placeholder('skeleton', { animate: 'none' });
-        assert.ok(!result.body.includes('<animate'));
-    });
-
-    test('throws on invalid type', () => {
-        assert.throws(() => placeholder('video', {}), /Type must be one of/);
-    });
-
-    test('throws on invalid width', () => {
-        assert.throws(() => placeholder('image', { width: '5000' }), /width/);
-    });
-
-    test('throws on invalid avatar shape', () => {
-        assert.throws(() => placeholder('skeleton', { avatar: 'hexagon' }), /avatar/);
-    });
-
-    test('throws on invalid speed', () => {
-        assert.throws(() => placeholder('skeleton', { speed: '99' }), /speed/);
-    });
-});

package/tests/unit/qrcode.test.ts

@@ -1,83 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import qrcode from '../../src/modules/v4/qrcode.js';
-
-const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
-
-describe('qrcode', () => {
-    test('returns PNG buffer by default', async () => {
-        const result = await qrcode({ url: 'https://example.com' });
-        assert.equal(result.contentType, 'image/png');
-        assert.ok(Buffer.isBuffer(result.body));
-        assert.ok((result.body as Buffer).subarray(0, 4).equals(PNG_MAGIC));
-    });
-
-    test('returns data URL with format=base64', async () => {
-        const result = await qrcode({ url: 'https://example.com', format: 'base64' });
-        assert.equal(result.contentType, 'application/json');
-        assert.match(result.body as string, /^data:image\/png;base64,/);
-    });
-
-    test('throws on invalid format', async () => {
-        await assert.rejects(() => qrcode({ url: 'https://example.com', format: 'jpg' as 'png' }), /format/);
-    });
-
-    test('throws on missing url', async () => {
-        await assert.rejects(() => qrcode({ url: '' }));
-    });
-
-    test('accepts custom size', async () => {
-        const result = await qrcode({ url: 'https://example.com', size: 400 });
-        assert.equal(result.contentType, 'image/png');
-    });
-
-    test('throws on invalid size', async () => {
-        await assert.rejects(() => qrcode({ url: 'https://example.com', size: 9999 }), /size/);
-    });
-
-    test('accepts custom colors', async () => {
-        const result = await qrcode({ url: 'https://example.com', dark: 'ff0000', light: 'ffffff' });
-        assert.equal(result.contentType, 'image/png');
-    });
-
-    test('throws on invalid dark color', async () => {
-        await assert.rejects(() => qrcode({ url: 'https://example.com', dark: 'xyz' }), /color/i);
-    });
-
-    test('throws on invalid light color', async () => {
-        await assert.rejects(() => qrcode({ url: 'https://example.com', light: 'nope' }), /color/i);
-    });
-
-    test('accepts correction level', async () => {
-        const result = await qrcode({ url: 'https://example.com', correction: 'H' });
-        assert.equal(result.contentType, 'image/png');
-    });
-
-    test('throws on invalid correction level', async () => {
-        await assert.rejects(() => qrcode({ url: 'https://example.com', correction: 'X' as 'L' }), /correction/);
-    });
-
-    test('accepts custom margin', async () => {
-        const result = await qrcode({ url: 'https://example.com', margin: 0 });
-        assert.equal(result.contentType, 'image/png');
-    });
-
-    test('throws on invalid margin', async () => {
-        await assert.rejects(() => qrcode({ url: 'https://example.com', margin: 99 }), /margin/);
-    });
-
-    test('throws on non-HTTPS icon URL', async () => {
-        await assert.rejects(
-            () => qrcode({ url: 'https://example.com', icon: 'http://example.com/icon.png' }),
-            /HTTPS/,
-        );
-    });
-
-    test('throws on unreachable icon URL', async () => {
-        await assert.rejects(
-            () => qrcode({ url: 'https://example.com', icon: 'https://localhost:1/nope.png' }),
-            /Failed to fetch icon|fetch/i,
-        );
-    });
-});

package/tests/unit/regex.test.ts

@@ -1,95 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import regex from '../../src/modules/v4/regex.js';
-
-describe('regex', () => {
-    describe('basic matching', () => {
-        test('finds a simple match', () => {
-            const r = regex('hello', 'hello world');
-            assert.equal(r.valid, true);
-            assert.equal(r.count, 1);
-            assert.equal(r.matches[0]!.match, 'hello');
-            assert.equal(r.matches[0]!.index, 0);
-        });
-
-        test('finds multiple matches', () => {
-            const r = regex('\\d+', 'abc 42 def 7');
-            assert.equal(r.count, 2);
-            assert.equal(r.matches[0]!.match, '42');
-            assert.equal(r.matches[1]!.match, '7');
-        });
-
-        test('no match returns empty array', () => {
-            const r = regex('xyz', 'hello world');
-            assert.equal(r.valid, true);
-            assert.equal(r.count, 0);
-            assert.deepEqual(r.matches, []);
-        });
-    });
-
-    describe('flags', () => {
-        test('flag i enables case-insensitive matching', () => {
-            const r = regex('hello', 'HELLO world', 'i');
-            assert.equal(r.count, 1);
-            assert.equal(r.matches[0]!.match, 'HELLO');
-        });
-
-        test('invalid flag x is silently ignored', () => {
-            const r = regex('hello', 'hello world', 'x');
-            assert.equal(r.valid, true);
-            assert.equal(r.count, 1);
-        });
-
-        test('g flag is always present', () => {
-            const r = regex('a', 'aaa', '');
-            assert.ok(r.flags.includes('g'));
-        });
-    });
-
-    describe('capture groups', () => {
-        test('numbered groups are returned', () => {
-            const r = regex('(\\d{4})-(\\d{2})', '2026-05');
-            assert.deepEqual(r.matches[0]!.groups, ['2026', '05']);
-        });
-
-        test('named groups are returned', () => {
-            const r = regex('(?<year>\\d{4})-(?<month>\\d{2})', '2026-05');
-            assert.equal(r.matches[0]!.namedGroups.year, '2026');
-            assert.equal(r.matches[0]!.namedGroups.month, '05');
-        });
-
-        test('no groups returns empty arrays', () => {
-            const r = regex('hello', 'hello');
-            assert.deepEqual(r.matches[0]!.groups, []);
-            assert.deepEqual(r.matches[0]!.namedGroups, {});
-        });
-    });
-
-    describe('invalid pattern', () => {
-        test('invalid regex returns valid: false', () => {
-            const r = regex('[invalid', 'hello');
-            assert.equal(r.valid, false);
-            assert.equal(r.count, 0);
-            assert.deepEqual(r.matches, []);
-        });
-    });
-
-    describe('errors', () => {
-        test('missing pattern throws', () => {
-            assert.throws(() => regex('', 'hello'), /pattern/);
-        });
-
-        test('missing text throws', () => {
-            assert.throws(() => regex('hello', ''), /text/);
-        });
-
-        test('pattern too long throws', () => {
-            assert.throws(() => regex('a'.repeat(201), 'hello'), /200/);
-        });
-
-        test('text too long throws', () => {
-            assert.throws(() => regex('hello', 'a'.repeat(1001)), /1000/);
-        });
-    });
-});

package/tests/unit/statistics.test.ts

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

@@ -1,108 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import { lorem, number, slug, stats } 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/tic_tac_toe.test.ts

@@ -1,56 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import tic_tac_toe from '../../src/modules/v4/tic_tac_toe.js';
-import type { TicTacToeStorage } from '../../src/types/storage.js';
-
-function makeStorage(): TicTacToeStorage {
-    return { games: {}, sessions: {}, rateLimits: {} };
-}
-
-describe('tic_tac_toe', () => {
-    test('list returns empty games array', () => {
-        const result = tic_tac_toe('list', { storage: makeStorage() });
-        assert.ok(Array.isArray(result.games));
-    });
-
-    test('play creates a game and makes a move', () => {
-        const storage = makeStorage();
-        const result = tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST1', storage });
-        assert.ok((result.message as string).includes('Move sent'));
-    });
-
-    test('fetch returns game state', () => {
-        const storage = makeStorage();
-        tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST2', storage });
-        const result = tic_tac_toe('fetch', { username: 'alice', game: 'TEST2', storage });
-        assert.equal(result.id, 'TEST2');
-    });
-
-    test('forfeit throws on non-player', () => {
-        const storage = makeStorage();
-        tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST3', storage });
-        assert.throws(
-            () => tic_tac_toe('forfeit', { username: 'charlie', session: 'c1', game: 'TEST3', storage }),
-            /not a player/,
-        );
-    });
-
-    test('throws on missing username', () => {
-        assert.throws(
-            () => tic_tac_toe('play', { move: '1-1', session: 's', game: 'G', storage: makeStorage() }),
-            /username/,
-        );
-    });
-
-    test('throws on missing move', () => {
-        assert.throws(
-            () => tic_tac_toe('play', { username: 'alice', session: 's', game: 'G', storage: makeStorage() }),
-            /move/i,
-        );
-    });
-
-    test('throws on invalid action', () => {
-        assert.throws(() => tic_tac_toe('reset', { username: 'alice', storage: makeStorage() }), /Invalid action/);
-    });
-});