@20syldev/api 4.7.0 → 4.9.0

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/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/);
-    });
-});

package/tests/unit/time.test.ts

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

package/tests/unit/token.test.ts

@@ -1,62 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import token from '../../src/modules/v4/token.js';
-
-describe('token', () => {
-    test('alpha length', () => {
-        const t = token(24, 'alpha');
-        assert.equal(t.length, 24);
-        assert.match(t, /^[a-zA-Z]+$/);
-    });
-
-    test('alphanum length', () => {
-        const t = token(32, 'alphanum');
-        assert.equal(t.length, 32);
-        assert.match(t, /^[a-zA-Z0-9]+$/);
-    });
-
-    test('hex contains only hex chars', () => {
-        const t = token(16, 'hex');
-        assert.equal(t.length, 16);
-        assert.match(t, /^[0-9a-f]+$/);
-    });
-
-    test('num contains only digits', () => {
-        const t = token(20, 'num');
-        assert.match(t, /^\d+$/);
-    });
-
-    test('urlsafe chars only', () => {
-        const t = token(40, 'urlsafe');
-        assert.match(t, /^[a-zA-Z0-9_-]+$/);
-    });
-
-    test('uuid type produces hex', () => {
-        const t = token(32, 'uuid');
-        assert.equal(t.length, 32);
-    });
-
-    test('default type alphanum', () => {
-        const t = token(20);
-        assert.match(t, /^[a-zA-Z0-9]+$/);
-    });
-
-    test('throws below minimum length', () => {
-        assert.throws(() => token(5, 'alpha'), /greater than or equal to 12/);
-    });
-
-    test('throws above maximum length', () => {
-        assert.throws(() => token(5000, 'alpha'), /4096/);
-    });
-
-    test('throws on invalid type', () => {
-        assert.throws(() => token(20, 'martian'), /Invalid token type/);
-    });
-
-    test('two tokens are different (entropy check)', () => {
-        const a = token(32, 'alphanum');
-        const b = token(32, 'alphanum');
-        assert.notEqual(a, b);
-    });
-});

package/tests/unit/username.test.ts

@@ -1,35 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import username from '../../src/modules/v4/username.js';
-
-describe('username', () => {
-    test('returns expected fields', () => {
-        const result = username();
-        assert.ok('username' in result);
-        assert.ok('number' in result);
-        assert.ok('adjective' in result);
-        assert.ok('animal' in result);
-        assert.ok('job' in result);
-    });
-
-    test('username is a non-empty string', () => {
-        const result = username();
-        assert.equal(typeof result.username, 'string');
-        assert.ok((result.username as string).length > 0);
-    });
-
-    test('number is between 0 and 99', () => {
-        const result = username();
-        const n = result.number as number;
-        assert.ok(n >= 0 && n <= 99);
-    });
-
-    test('produces varied usernames', () => {
-        const seen = new Set<string>();
-        for (let i = 0; i < 10; i++) {
-            seen.add(username().username as string);
-        }
-        assert.ok(seen.size > 1);
-    });
-});

package/tests/unit/validate.test.ts

@@ -1,72 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, test } from 'node:test';
-
-import { email, iban, luhn } from '../../src/modules/v4/validate.js';
-
-describe('validate', () => {
-    describe('luhn', () => {
-        test('valid Visa test card', () => {
-            const result = luhn('4111111111111111');
-            assert.equal(result.valid, true);
-        });
-
-        test('invalid card number', () => {
-            const result = luhn('4111111111111112');
-            assert.equal(result.valid, false);
-        });
-
-        test('strips spaces and dashes', () => {
-            const result = luhn('4111-1111 1111-1111');
-            assert.equal(result.valid, true);
-            assert.equal(result.value, '4111111111111111');
-        });
-
-        test('throws on non-digit', () => {
-            assert.throws(() => luhn('4111ABC11111111'), /only digits/);
-        });
-
-        test('throws on too short', () => {
-            assert.throws(() => luhn('411111'), /between 12 and 19/);
-        });
-    });
-
-    describe('iban', () => {
-        test('valid French IBAN', () => {
-            const result = iban('FR1420041010050500013M02606');
-            assert.equal(result.valid, true);
-            assert.equal(result.country, 'FR');
-        });
-
-        test('invalid checksum', () => {
-            const result = iban('FR1420041010050500013M02607');
-            assert.equal(result.valid, false);
-        });
-
-        test('strips spaces', () => {
-            const result = iban('FR14 2004 1010 0505 0001 3M02 606');
-            assert.equal(result.valid, true);
-        });
-
-        test('throws on bad format', () => {
-            assert.throws(() => iban('1234'), /Invalid IBAN format/);
-        });
-    });
-
-    describe('email', () => {
-        test('valid email', () => {
-            assert.equal(email('hello@example.com').valid, true);
-        });
-
-        test('rejects missing domain', () => {
-            assert.equal(email('hello@').valid, false);
-        });
-
-        test('rejects missing @', () => {
-            assert.equal(email('helloexample.com').valid, false);
-        });
-
-        test('rejects spaces', () => {
-            assert.equal(email('hello world@example.com').valid, false);
-        });
-    });
-});

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "NodeNext",
-        "moduleResolution": "NodeNext",
-        "allowJs": true,
-        "strict": true,
-        "noUncheckedIndexedAccess": true,
-        "outDir": "dist",
-        "rootDir": "src",
-        "declaration": false,
-        "sourceMap": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true
-    },
-    "include": ["src"]
-}

package/tsconfig.test.json

@@ -1,9 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "rootDir": ".",
-        "noEmit": true,
-        "types": ["node"]
-    },
-    "include": ["src", "tests"]
-}