@20syldev/api 3.5.0 → 4.1.0

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');
+    });
+});

package/tests/unit/token.test.ts

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

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

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

@@ -0,0 +1,17 @@
+{
+    "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

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