@20syldev/api 4.1.0 → 4.2.0

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://api.sylvain.sh"><img src="https://api.sylvain.sh/favicon.ico" alt="Logo" width="25%" height="auto"/></a>
 
   # API Personnelle
-  [![Version](https://custom-icon-badges.demolab.com/badge/Version%20:-v4.1.0-6479ee?logo=api.sylvain.sh&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
+  [![Version](https://custom-icon-badges.demolab.com/badge/Version%20:-v4.2.0-6479ee?logo=api.sylvain.sh&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
 </div>
 
 ---
@@ -32,10 +32,10 @@ Pour démarrer un serveur local avec tous les endpoints :
 $ npm run build && npm start
 ```
 ```console
-> @20syldev/api@4.1.0 build
+> @20syldev/api@4.2.0 build
 > tsc
 
-> @20syldev/api@4.1.0 start
+> @20syldev/api@4.2.0 start
 > node dist/app.js
 
 API is running on
@@ -93,16 +93,21 @@ import {
     chat,              // Système de chat temporaire
     color,             // Génération de couleurs aléatoires
     convert,           // Conversions d'unités
+    dice,              // Lanceur de dés RPG
     domain,            // Informations de domaine aléatoires
+    encode,            // Encodage / décodage (base64, morse, rot13, caesar, binaire)
     hash,              // Hachage de texte
     hyperplanning,     // Analyse de calendriers
     levenshtein,       // Distance entre chaînes
     personal,          // Informations personnelles aléatoires
     qrcode,            // Génération de QR codes
+    statistics,        // Statistiques descriptives
     tic_tac_toe,       // Jeu de morpion
     time,              // Informations temporelles
+    text,              // Utilitaires texte (slug, stats, lorem, nombre en lettres)
     token,             // Génération de jetons sécurisés
-    username           // Génération de noms d'utilisateur
+    username,          // Génération de noms d'utilisateur
+    validate           // Validation (Luhn, IBAN, email)
 } from '@20syldev/api/v4';
 ```
 

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "4.1.0",
+    "version": "4.2.0",
     "name": "@20syldev/api",
     "description": "Node.js API with multiple features. Check the documentation at https://docs.sylvain.sh",
     "main": "dist/app.js",

package/src/config/versions.ts

@@ -79,7 +79,10 @@ const v3 = {
 const v4 = {
     get: merge(v3.get, [
         { name: 'dice', path: '/dice?roll={NdX+M}' },
+        { name: 'encode', path: '/encode?method={method}&text={text}(&shift={shift})' },
         { name: 'statistics', path: '/statistics?values={n1,n2,n3,...}' },
+        { name: 'text', path: '/text?method={method}(&value={value}&type={type}&count={count}&lang={lang})' },
+        { name: 'validate', path: '/validate?type={type}&value={value}' },
     ]),
     post: [...v3.post],
 };

package/src/middleware/cors.ts

@@ -8,7 +8,7 @@ const __dirname = dirname(__filename);
 
 export function setupCors(app: Express): void {
     app.set('trust proxy', 1);
-    app.use(cors({ methods: ['GET', 'POST', 'PATCH', 'DELETE', 'OPTIONS'] }));
+    app.use(cors({ methods: ['GET', 'POST'] }));
     app.use(express.urlencoded({ extended: true }));
     app.use(express.json());
 

package/src/modules/v4/chat.ts

@@ -34,10 +34,8 @@ export default function chat(action: string, params: ChatParams): ChatMessage[]
         return getPrivateChat(params, privateChats);
     } else if (action === 'fetch') {
         return fetchMessages(messages);
-    } else if (action === 'clear') {
-        return clearPrivateChat(params, privateChats, sessions, u);
     } else {
-        throw new Error('Invalid action. Use "message", "private", "fetch", or "clear"');
+        throw new Error('Invalid action. Use "message", "private", or "fetch"');
     }
 }
 
@@ -99,24 +97,3 @@ function fetchMessages(messages: ChatMessage[]): ChatMessage[] {
     if (messages.length > 0) return messages;
     throw new Error('No messages stored.');
 }
-
-function clearPrivateChat(
-    params: ChatParams,
-    privateChats: Record<string, ChatMessage[]>,
-    sessions: Record<string, { user: string; last: number }>,
-    u: string,
-): { message: string } {
-    const { token, session } = params;
-
-    if (!token) throw new Error('Please provide a valid token');
-    if (!session) throw new Error('Please provide a valid session ID');
-    if (sessions[u] && sessions[u].user !== session) {
-        throw new Error('Session ID mismatch');
-    }
-    if (!privateChats[token]) throw new Error('Invalid or expired token.');
-
-    delete privateChats[token];
-    delete sessions[u];
-
-    return { message: 'Private chat cleared successfully' };
-}

package/src/modules/v4/tic_tac_toe.ts

@@ -44,43 +44,11 @@ export default function tic_tac_toe(action: string, params: TicTacToeParams): Re
         return playMove(params, games, sessions, u, now);
     } else if (action === 'fetch') {
         return fetchGame(params, games, u);
-    } else if (action === 'forfeit') {
-        return forfeitGame(params, games, sessions);
     } else {
-        throw new Error('Invalid action. Use "play", "fetch", "list", or "forfeit"');
+        throw new Error('Invalid action. Use "play", "fetch", or "list"');
     }
 }
 
-function forfeitGame(
-    params: TicTacToeParams,
-    games: Record<string, TicTacToeGame>,
-    sessions: Record<string, { user: string; last: number }>,
-): Record<string, unknown> {
-    const { game, session } = params;
-
-    if (!game) throw new Error('Please provide a valid game ID');
-    if (!session) throw new Error('Please provide a valid session ID');
-    if (!games[game]) throw new Error('Game not found');
-
-    const u = params.username!.toLowerCase();
-    if (sessions[u] && sessions[u].user !== session) {
-        throw new Error('Session ID mismatch');
-    }
-
-    const players = games[game]!.players;
-    if (!players.includes(u)) throw new Error('You are not a player in this game');
-
-    const winner = players.find((p) => p !== u) ?? null;
-    delete games[game];
-    delete sessions[u];
-
-    return {
-        message: `${params.username} forfeited the game.${winner ? ` ${winner} wins.` : ''}`,
-        winner,
-        loser: params.username,
-    };
-}
-
 function playMove(
     params: TicTacToeParams,
     games: Record<string, TicTacToeGame>,

package/src/modules/v4.ts

@@ -5,13 +5,16 @@ export { default as color } from './v4/color.js';
 export { default as convert } from './v4/convert.js';
 export { default as dice } from './v4/dice.js';
 export { default as domain } from './v4/domain.js';
+export * as encode from './v4/encode.js';
 export { default as hash } from './v4/hash.js';
 export { default as hyperplanning } from './v4/hyperplanning.js';
 export { default as levenshtein } from './v4/levenshtein.js';
 export { default as personal } from './v4/personal.js';
 export { default as qrcode } from './v4/qrcode.js';
 export { default as statistics } from './v4/statistics.js';
+export * as text from './v4/text.js';
 export { default as tic_tac_toe } from './v4/tic_tac_toe.js';
 export { default as time } from './v4/time.js';
 export { default as token } from './v4/token.js';
 export { default as username } from './v4/username.js';
+export * as validate from './v4/validate.js';

package/src/routes/get.ts

@@ -173,6 +173,29 @@ router.get('/:version/dice', (req: Request, res: Response) => {
     }
 });
 
+// Encode / decode text
+router.get('/:version/encode', (req: Request, res: Response) => {
+    const { method, text, shift } = req.query;
+    const { version } = req.params;
+
+    const encode = (req.module as { encode?: Record<string, (v: string, v2?: string) => string> }).encode;
+    if (!encode) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/encode`);
+        return;
+    }
+    if (!method || !encode[method as string]) {
+        error(res, 400, 'Please provide a valid method (?method={method})', `${version}/encode`);
+        return;
+    }
+
+    try {
+        const result = encode[method as string]!(text as string, shift as string);
+        res.jsonResponse({ method, result });
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/encode`);
+    }
+});
+
 // GET planning error
 router.get('/:version/hyperplanning', (_req: Request, res: Response) => {
     error(res, 405, 'This endpoint only supports POST requests.');
@@ -269,6 +292,70 @@ router.get('/:version/statistics', (req: Request, res: Response) => {
     }
 });
 
+// Text utilities (slug, stats, lorem, number)
+router.get('/:version/text', (req: Request, res: Response) => {
+    const { method, value, type, count, lang, text } = req.query;
+    const { version } = req.params;
+
+    const textMod = (req.module as { text?: Record<string, (...args: string[]) => unknown> }).text;
+    if (!textMod) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/text`);
+        return;
+    }
+    if (!method || !textMod[method as string]) {
+        error(res, 400, 'Please provide a valid method (?method={slug|stats|lorem|number})', `${version}/text`);
+        return;
+    }
+
+    try {
+        let result: unknown;
+        switch (method) {
+            case 'slug':
+            case 'stats':
+                result = textMod[method as string]!((value ?? text) as string);
+                break;
+            case 'lorem':
+                result = textMod.lorem!((type as string) || 'words', (count as string) || '5');
+                break;
+            case 'number':
+                result = textMod.number!(value as string, (lang as string) || 'en');
+                break;
+            default:
+                throw new Error('Unknown method');
+        }
+        res.jsonResponse({ method, result });
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/text`);
+    }
+});
+
+// Validate data (luhn, iban, email)
+router.get('/:version/validate', (req: Request, res: Response) => {
+    const { type, value } = req.query;
+    const { version } = req.params;
+
+    const validate = (req.module as { validate?: Record<string, (v: string) => unknown> }).validate;
+    if (!validate) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/validate`);
+        return;
+    }
+    if (!type || !validate[type as string]) {
+        error(res, 400, 'Please provide a valid type (?type={luhn|iban|email})', `${version}/validate`);
+        return;
+    }
+    if (!value) {
+        error(res, 400, 'Please provide a value (&value={value})', `${version}/validate`);
+        return;
+    }
+
+    try {
+        const result = validate[type as string]!(value as string);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/validate`);
+    }
+});
+
 // GET tic-tac-toe errors
 router.get('/:version/tic-tac-toe', (_req: Request, res: Response) => {
     error(res, 405, 'This endpoint only supports POST requests.');

package/tests/integration/api.test.ts

@@ -51,7 +51,10 @@ describe('GET / (version listing)', () => {
         assert.equal(body.version, 'v4');
         const endpoints = body.endpoints as Record<string, Record<string, string>>;
         assert.ok('dice' in endpoints.get!);
+        assert.ok('encode' in endpoints.get!);
         assert.ok('statistics' in endpoints.get!);
+        assert.ok('text' in endpoints.get!);
+        assert.ok('validate' in endpoints.get!);
     });
 
     test('invalid version returns 404', async () => {
@@ -148,6 +151,24 @@ describe('GET /v4/dice', () => {
     });
 });
 
+describe('GET /v4/encode', () => {
+    test('base64 encode', async () => {
+        const { status, body } = await getJson('/v4/encode?method=base64encode&text=hello');
+        assert.equal(status, 200);
+        assert.equal(body.result, 'aGVsbG8=');
+    });
+
+    test('rot13', async () => {
+        const { body } = await getJson('/v4/encode?method=rot13&text=Hello');
+        assert.equal(body.result, 'Uryyb');
+    });
+
+    test('missing method returns 400', async () => {
+        const { status } = await getJson('/v4/encode?text=hello');
+        assert.equal(status, 400);
+    });
+});
+
 describe('GET /v4/domain', () => {
     test('has TLD', async () => {
         const { status, body } = await getJson('/v4/domain');
@@ -205,6 +226,23 @@ describe('GET /v4/statistics', () => {
     });
 });
 
+describe('GET /v4/text', () => {
+    test('slug', async () => {
+        const { body } = await getJson('/v4/text?method=slug&value=Hello%20World');
+        assert.equal(body.result, 'hello-world');
+    });
+
+    test('number en', async () => {
+        const { body } = await getJson('/v4/text?method=number&value=42&lang=en');
+        assert.equal(body.result, 'forty-two');
+    });
+
+    test('lorem words', async () => {
+        const { body } = await getJson('/v4/text?method=lorem&type=words&count=5');
+        assert.equal((body.result as string).split(' ').length, 5);
+    });
+});
+
 describe('GET /v4/time', () => {
     test('live', async () => {
         const { status, body } = await getJson('/v4/time');
@@ -222,6 +260,23 @@ describe('GET /v4/time', () => {
     });
 });
 
+describe('GET /v4/validate', () => {
+    test('valid luhn', async () => {
+        const { body } = await getJson('/v4/validate?type=luhn&value=4111111111111111');
+        assert.equal(body.valid, true);
+    });
+
+    test('valid email', async () => {
+        const { body } = await getJson('/v4/validate?type=email&value=hello%40example.com');
+        assert.equal(body.valid, true);
+    });
+
+    test('invalid type returns 400', async () => {
+        const { status } = await getJson('/v4/validate?type=foo&value=bar');
+        assert.equal(status, 400);
+    });
+});
+
 describe('GET /v4/username', () => {
     test('has fields', async () => {
         const { status, body } = await getJson('/v4/username');

package/docs/changelog.md

@@ -1,333 +0,0 @@
-# Changelog
-
-## Exemples curl
-
-```bash
-# dice
-curl -X GET "http://127.0.0.1:3000/v4/dice?roll=2d6%2B3"
-
-# encode
-curl -X GET "http://127.0.0.1:3000/v4/encode?method=base64encode&text=hello"
-curl -X GET "http://127.0.0.1:3000/v4/encode?method=morse&text=SOS"
-curl -X GET "http://127.0.0.1:3000/v4/encode?method=caesar&text=hello&shift=3"
-
-# geo
-curl -X GET "http://127.0.0.1:3000/v4/geo?lat1=48.8566&lon1=2.3522&lat2=43.2965&lon2=5.3698"
-
-# palette
-curl -X GET "http://127.0.0.1:3000/v4/palette?color=%23ff6600&type=triadic"
-
-# statistics
-curl -X GET "http://127.0.0.1:3000/v4/statistics?values=1,2,3,4,5"
-
-# text - stats
-curl -X GET "http://127.0.0.1:3000/v4/text?method=stats&value=Hello+world"
-
-# text - slug
-curl -X GET "http://127.0.0.1:3000/v4/text?method=slug&value=Héllo+Wörld%21"
-
-# text - lorem
-curl -X GET "http://127.0.0.1:3000/v4/text?method=lorem&type=sentences&count=3"
-
-# text - number
-curl -X GET "http://127.0.0.1:3000/v4/text?method=number&value=42&lang=fr"
-
-# validate - luhn
-curl -X GET "http://127.0.0.1:3000/v4/validate?type=luhn&value=4532015112830366"
-
-# validate - iban
-curl -X GET "http://127.0.0.1:3000/v4/validate?type=iban&value=FR7630006000011234567890189"
-
-# validate - email
-curl -X GET "http://127.0.0.1:3000/v4/validate?type=email&value=user%40example.com"
-
-# algorithms - roman
-curl -X GET "http://127.0.0.1:3000/v4/algorithms?method=roman&value=42"
-curl -X GET "http://127.0.0.1:3000/v4/algorithms?method=roman&value=XLII"
-
-# REST v4.2 - jouer un coup (PATCH)
-curl -X PATCH "http://127.0.0.1:3000/v4/tic-tac-toe/{gameId}" \
-  -H "Content-Type: application/json" \
-  -d '{"username":"alice","move":"A1","session":"abc123"}'
-
-# REST v4.2 - forfait (DELETE tic-tac-toe)
-curl -X DELETE "http://127.0.0.1:3000/v4/tic-tac-toe/{gameId}" \
-  -H "Content-Type: application/json" \
-  -d '{"username":"alice","session":"abc123"}'
-
-# REST v4.2 - vider un chat (DELETE chat)
-curl -X DELETE "http://127.0.0.1:3000/v4/chat/{token}" \
-  -H "Content-Type: application/json" \
-  -d '{"username":"alice","session":"abc123"}'
-```
-
-
-
-## v4.2.0
-
-### REST endpoints pour tic-tac-toe et chat
-
-Les endpoints existants ont été étendus avec des méthodes HTTP REST. Uniquement disponible en `v4+`.
-
-#### PATCH `/v4/tic-tac-toe/:game`
-
-Jouer un coup dans une partie.
-
-**Body (JSON) :**
-| Param | Type | Description |
-|-------|------|-------------|
-| `username` | string | Nom du joueur |
-| `move` | string | Case jouée (ex: `A1`) |
-| `session` | string | ID de session |
-
----
-
-#### DELETE `/v4/tic-tac-toe/:game`
-
-Abandonner une partie (forfeit).
-
-**Body (JSON) :**
-| Param | Type | Description |
-|-------|------|-------------|
-| `username` | string | Nom du joueur |
-| `session` | string | ID de session |
-
----
-
-#### DELETE `/v4/chat/:token`
-
-Effacer tous les messages d'un chat privé (clear).
-
-**Body (JSON) :**
-| Param | Type | Description |
-|-------|------|-------------|
-| `username` | string | Nom de l'utilisateur |
-| `session` | string | ID de session |
-
----
-
-### Autres changements v4.2.0
-
-- CORS : ajout de `PATCH`, `DELETE`, `OPTIONS` dans les headers autorisés
-- Nouveau helper `supportsRest()` dans `src/utils/version.ts`
-
----
-
-## v4.1.0
-
-### Nouveaux endpoints
-
-#### GET `/v4/dice`
-
-Lance des dés en notation RPG.
-
-**Query params :**
-| Param | Requis | Description | Exemple |
-|-------|--------|-------------|---------|
-| `roll` | oui | Notation NdX ou NdX+M | `2d6+3` |
-
-**Note :** le `+` dans l'URL peut être encodé en espace (`2d6 3`) — les deux sont acceptés.
-
-**Réponse :**
-```json
-{
-  "roll": "2d6+3",
-  "count": 2,
-  "sides": 6,
-  "modifier": 3,
-  "results": [4, 2],
-  "total": 9
-}
-```
-
-Limites : 1–100 dés, 2–1000 faces.
-
----
-
-#### GET `/v4/encode`
-
-Encode ou décode du texte dans différents formats.
-
-**Query params :**
-| Param | Requis | Description |
-|-------|--------|-------------|
-| `method` | oui | Voir liste ci-dessous |
-| `value` | oui | Texte à traiter |
-| `shift` | non | Décalage pour Caesar (défaut : 13) |
-
-**Méthodes disponibles :**
-| `method` | Description |
-|----------|-------------|
-| `base64encode` | Encode en Base64 |
-| `base64decode` | Décode du Base64 |
-| `urlencode` | Encode pour URL |
-| `urldecode` | Décode une URL |
-| `morse` | Texte → Morse |
-| `unmorse` | Morse → Texte |
-| `rot13` | ROT-13 |
-| `caesar` | Chiffre de César (nécessite `shift`) |
-| `binary` | Texte → binaire 8 bits |
-| `unbinary` | Binaire → texte |
-
----
-
-#### GET `/v4/geo`
-
-Calcule la distance et le cap entre deux coordonnées GPS (Haversine).
-
-**Query params :**
-| Param | Requis | Description |
-|-------|--------|-------------|
-| `lat1` | oui | Latitude point A (-90/+90) |
-| `lon1` | oui | Longitude point A (-180/+180) |
-| `lat2` | oui | Latitude point B |
-| `lon2` | oui | Longitude point B |
-
-**Réponse :**
-```json
-{
-  "distance": { "km": 1214.652, "miles": 754.801, "nauticalMiles": 655.879 },
-  "bearing": { "degrees": 157.34, "cardinal": "SSE" },
-  "from": { "lat": 48.8566, "lon": 2.3522 },
-  "to": { "lat": 43.2965, "lon": 5.3698 }
-}
-```
-
----
-
-#### GET `/v4/palette`
-
-Génère une palette de couleurs harmonieuse à partir d'une couleur HEX.
-
-**Query params :**
-| Param | Requis | Description |
-|-------|--------|-------------|
-| `color` | oui | Couleur base en HEX (`#RRGGBB`) |
-| `type` | oui | Type de palette |
-
-**Types disponibles :**
-| `type` | Couleurs générées |
-|--------|------------------|
-| `complementary` | 2 couleurs (opposées) |
-| `triadic` | 3 couleurs (120°) |
-| `analogous` | 5 couleurs (-60° à +60°) |
-| `tetradic` | 4 couleurs (90°) |
-| `split-complementary` | 3 couleurs |
-
-Chaque couleur retournée a `hex`, `rgb`, `hsl`.
-
----
-
-#### GET `/v4/statistics`
-
-Calcule des statistiques descriptives sur une liste de nombres.
-
-**Query params :**
-| Param | Requis | Description |
-|-------|--------|-------------|
-| `values` | oui | Nombres séparés par des virgules |
-
-**Réponse :**
-```json
-{
-  "count": 5,
-  "sum": 15,
-  "min": 1,
-  "max": 5,
-  "range": 4,
-  "mean": 3,
-  "median": 3,
-  "mode": [],
-  "variance": 2,
-  "stddev": 1.414214
-}
-```
-
----
-
-#### GET `/v4/text`
-
-Manipulation et génération de texte.
-
-**Query params :**
-| Param | Requis | Description |
-|-------|--------|-------------|
-| `action` | oui | Voir liste ci-dessous |
-| `value` | non | Texte source (selon action) |
-| `type` | non | `words`, `sentences`, `paragraphs` (pour `lorem`) |
-| `count` | non | Nombre d'éléments (pour `lorem`, défaut 5) |
-| `lang` | non | `fr` ou `en` (pour `number`) |
-
-**Actions disponibles :**
-| `action` | Description | Params requis |
-|----------|-------------|---------------|
-| `stats` | Statistiques du texte | `value` |
-| `slug` | Convertit en slug URL | `value` |
-| `lorem` | Génère du Lorem Ipsum | `type`, `count` |
-| `number` | Nombre en lettres | `value`, `lang` |
-
-**Réponse `stats` :**
-```json
-{
-  "characters": 42,
-  "charactersNoSpaces": 35,
-  "words": 8,
-  "sentences": 2,
-  "paragraphs": 1,
-  "readingTime": "3s",
-  "mostFrequentChar": "e"
-}
-```
-
----
-
-#### GET `/v4/validate`
-
-Valide différents formats de données.
-
-**Query params :**
-| Param | Requis | Description |
-|-------|--------|-------------|
-| `type` | oui | `luhn`, `iban`, `email` |
-| `value` | oui | Valeur à valider |
-
-**Réponse `luhn` (numéro de carte) :**
-```json
-{ "valid": true, "value": "4532015112830366" }
-```
-
-**Réponse `iban` :**
-```json
-{ "valid": true, "value": "FR7630006000011234567890189", "country": "FR" }
-```
-
-**Réponse `email` :**
-```json
-{ "valid": true, "value": "user@example.com" }
-```
-
----
-
-### Ajout à un endpoint existant
-
-#### GET `/v4/algorithms` — conversion de chiffres romains
-
-Nouvelle action `roman` sur l'endpoint algorithms.
-
-**Query params :**
-| Param | Requis | Description |
-|-------|--------|-------------|
-| `method` | oui | `roman` |
-| `value` | oui | Nombre entier (1–3999) ou chiffre romain |
-
-Bidirectionnel : `42` → `XLII`, `XLII` → `42`.
-
----
-
-### Infrastructure v4.1.0
-
-- **`src/app.ts`** : `export default app` + guard `NODE_ENV !== 'test'` pour les tests d'intégration
-- **`src/config/versions.ts`** : helper `merge()` pour dédoublonner les endpoints par `name`
-- **`tsconfig.test.json`** : étend le tsconfig principal, inclut `src/` et `tests/`
-- **`tests/tsconfig.json`** : pointe vers `tsconfig.test.json` pour la résolution IDE
-- **`package.json`** : script `npm test` avec `--test-force-exit` (requis car `setTimeout` dans chat/tic-tac-toe)

package/src/modules/v4/geo.ts

@@ -1,53 +0,0 @@
-export interface GeoResult {
-    distance: { km: number; miles: number; nauticalMiles: number };
-    bearing: { degrees: number; cardinal: string };
-    from: { lat: number; lon: number };
-    to: { lat: number; lon: number };
-}
-
-const EARTH_RADIUS_KM = 6371;
-const CARDINALS = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
-
-function toRad(deg: number): number {
-    return (deg * Math.PI) / 180;
-}
-
-function toDeg(rad: number): number {
-    return (rad * 180) / Math.PI;
-}
-
-function parseCoord(value: string, name: string, min: number, max: number): number {
-    const n = Number(value);
-    if (isNaN(n)) throw new Error(`${name} must be a number`);
-    if (n < min || n > max) throw new Error(`${name} must be between ${min} and ${max}`);
-    return n;
-}
-
-export default function geo(lat1: string, lon1: string, lat2: string, lon2: string): GeoResult {
-    const a = parseCoord(lat1, 'lat1', -90, 90);
-    const b = parseCoord(lon1, 'lon1', -180, 180);
-    const c = parseCoord(lat2, 'lat2', -90, 90);
-    const d = parseCoord(lon2, 'lon2', -180, 180);
-
-    const dLat = toRad(c - a);
-    const dLon = toRad(d - b);
-    const sa = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(a)) * Math.cos(toRad(c)) * Math.sin(dLon / 2) ** 2;
-    const distance = 2 * EARTH_RADIUS_KM * Math.asin(Math.sqrt(sa));
-
-    const y = Math.sin(toRad(d - b)) * Math.cos(toRad(c));
-    const x =
-        Math.cos(toRad(a)) * Math.sin(toRad(c)) - Math.sin(toRad(a)) * Math.cos(toRad(c)) * Math.cos(toRad(d - b));
-    const bearing = (toDeg(Math.atan2(y, x)) + 360) % 360;
-    const cardinal = CARDINALS[Math.round(bearing / 22.5) % 16]!;
-
-    return {
-        distance: {
-            km: +distance.toFixed(3),
-            miles: +(distance * 0.621371).toFixed(3),
-            nauticalMiles: +(distance * 0.539957).toFixed(3),
-        },
-        bearing: { degrees: +bearing.toFixed(2), cardinal },
-        from: { lat: a, lon: b },
-        to: { lat: c, lon: d },
-    };
-}

package/src/modules/v4/palette.ts

@@ -1,103 +0,0 @@
-export interface PaletteColor {
-    hex: string;
-    rgb: string;
-    hsl: string;
-}
-
-export interface PaletteResult {
-    base: PaletteColor;
-    type: string;
-    colors: PaletteColor[];
-}
-
-function hexToRgb(hex: string): [number, number, number] {
-    const clean = hex.replace('#', '');
-    if (!/^[0-9a-fA-F]{6}$/.test(clean)) throw new Error('Invalid HEX color (use #RRGGBB)');
-    return [parseInt(clean.slice(0, 2), 16), parseInt(clean.slice(2, 4), 16), parseInt(clean.slice(4, 6), 16)];
-}
-
-function rgbToHsl(r: number, g: number, b: number): [number, number, number] {
-    const r1 = r / 255,
-        g1 = g / 255,
-        b1 = b / 255;
-    const max = Math.max(r1, g1, b1),
-        min = Math.min(r1, g1, b1);
-    const l = (max + min) / 2;
-
-    if (max === min) return [0, 0, l];
-
-    const d = max - min;
-    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-    let h = 0;
-    if (max === r1) h = (g1 - b1) / d + (g1 < b1 ? 6 : 0);
-    else if (max === g1) h = (b1 - r1) / d + 2;
-    else h = (r1 - g1) / d + 4;
-
-    return [(h * 60 + 360) % 360, s, l];
-}
-
-function hslToRgb(h: number, s: number, l: number): [number, number, number] {
-    const c = (1 - Math.abs(2 * l - 1)) * s;
-    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
-    const m = l - c / 2;
-    let r1 = 0,
-        g1 = 0,
-        b1 = 0;
-    if (h < 60) [r1, g1, b1] = [c, x, 0];
-    else if (h < 120) [r1, g1, b1] = [x, c, 0];
-    else if (h < 180) [r1, g1, b1] = [0, c, x];
-    else if (h < 240) [r1, g1, b1] = [0, x, c];
-    else if (h < 300) [r1, g1, b1] = [x, 0, c];
-    else [r1, g1, b1] = [c, 0, x];
-    return [Math.round((r1 + m) * 255), Math.round((g1 + m) * 255), Math.round((b1 + m) * 255)];
-}
-
-function format(r: number, g: number, b: number): PaletteColor {
-    const [h, s, l] = rgbToHsl(r, g, b);
-    return {
-        hex: `#${[r, g, b].map((x) => x.toString(16).padStart(2, '0')).join('')}`,
-        rgb: `rgb(${r}, ${g}, ${b})`,
-        hsl: `hsl(${h.toFixed(1)}, ${(s * 100).toFixed(1)}%, ${(l * 100).toFixed(1)}%)`,
-    };
-}
-
-function fromHueShifts(base: [number, number, number], shifts: number[]): PaletteColor[] {
-    const [h, s, l] = base;
-    return shifts.map((shift) => {
-        const newH = (h + shift + 360) % 360;
-        const [r, g, b] = hslToRgb(newH, s, l);
-        return format(r, g, b);
-    });
-}
-
-export default function palette(color: string, type: string): PaletteResult {
-    if (!color) throw new Error('A base color is required');
-    if (!type) throw new Error('A palette type is required');
-
-    const [r, g, b] = hexToRgb(color);
-    const base = format(r, g, b);
-    const hsl = rgbToHsl(r, g, b);
-
-    let colors: PaletteColor[];
-    switch (type) {
-        case 'complementary':
-            colors = fromHueShifts(hsl, [0, 180]);
-            break;
-        case 'triadic':
-            colors = fromHueShifts(hsl, [0, 120, 240]);
-            break;
-        case 'analogous':
-            colors = fromHueShifts(hsl, [-60, -30, 0, 30, 60]);
-            break;
-        case 'tetradic':
-            colors = fromHueShifts(hsl, [0, 90, 180, 270]);
-            break;
-        case 'split-complementary':
-            colors = fromHueShifts(hsl, [0, 150, 210]);
-            break;
-        default:
-            throw new Error('Type must be one of: complementary, triadic, analogous, tetradic, split-complementary');
-    }
-
-    return { base, type, colors };
-}

package/src/modules/v4/placeholder.ts

@@ -1,122 +0,0 @@
-import { createCanvas } from 'canvas';
-
-export interface PlaceholderOptions {
-    width: number;
-    height: number;
-    bg?: string;
-    color?: string;
-    text?: string;
-    rows?: number;
-    avatar?: boolean;
-}
-
-function parseSize(value: string | undefined, name: string, def: number): number {
-    if (value === undefined) return def;
-    const n = Number(value);
-    if (isNaN(n)) throw new Error(`${name} must be a number`);
-    if (n < 1 || n > 4000) throw new Error(`${name} must be between 1 and 4000`);
-    return Math.floor(n);
-}
-
-function normalizeColor(value: string | undefined, def: string): string {
-    if (!value) return def;
-    const clean = value.startsWith('#') ? value : `#${value}`;
-    if (!/^#[0-9a-fA-F]{3,6}$/.test(clean)) throw new Error('Invalid color (use hex like #ff6600)');
-    return clean;
-}
-
-function generateImage(opts: PlaceholderOptions): Buffer {
-    const { width, height } = opts;
-    const bg = normalizeColor(opts.bg, '#cccccc');
-    const color = normalizeColor(opts.color, '#333333');
-    const text = opts.text ?? `${width}×${height}`;
-
-    const canvas = createCanvas(width, height);
-    const ctx = canvas.getContext('2d');
-
-    ctx.fillStyle = bg;
-    ctx.fillRect(0, 0, width, height);
-
-    const fontSize = Math.max(12, Math.min(width, height) / 8);
-    ctx.font = `bold ${fontSize}px sans-serif`;
-    ctx.fillStyle = color;
-    ctx.textAlign = 'center';
-    ctx.textBaseline = 'middle';
-    ctx.fillText(text, width / 2, height / 2);
-
-    return canvas.toBuffer('image/png');
-}
-
-function generateSkeleton(opts: PlaceholderOptions): string {
-    const { width, height } = opts;
-    const bg = normalizeColor(opts.bg, '#e2e8f0');
-    const shimmer = normalizeColor(opts.color, '#f1f5f9');
-    const rows = Math.max(1, Math.min(20, opts.rows ?? 3));
-    const avatar = !!opts.avatar;
-
-    const padding = Math.min(width, height) * 0.05;
-    const avatarSize = avatar ? Math.min(width, height) * 0.2 : 0;
-    const lineHeight = (height - padding * 2 - avatarSize - (avatar ? padding : 0)) / rows;
-    const lineThickness = Math.max(8, lineHeight * 0.5);
-    const radius = lineThickness / 2;
-
-    const lines: string[] = [];
-    const startY = padding + (avatar ? avatarSize + padding : 0);
-    for (let i = 0; i < rows; i++) {
-        const y = startY + i * lineHeight + (lineHeight - lineThickness) / 2;
-        const lineWidth = (width - padding * 2) * (i === rows - 1 ? 0.6 : 0.95);
-        lines.push(
-            `<rect x="${padding}" y="${y}" width="${lineWidth}" height="${lineThickness}" rx="${radius}" fill="url(#shimmer)" />`,
-        );
-    }
-
-    const avatarShape = avatar
-        ? `<circle cx="${padding + avatarSize / 2}" cy="${padding + avatarSize / 2}" r="${avatarSize / 2}" fill="url(#shimmer)" />`
-        : '';
-
-    return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
-  <defs>
-    <linearGradient id="shimmer" x1="0%" y1="0%" x2="100%" y2="0%">
-      <stop offset="0%" stop-color="${bg}">
-        <animate attributeName="offset" values="-2; 1" dur="1.5s" repeatCount="indefinite" />
-      </stop>
-      <stop offset="50%" stop-color="${shimmer}">
-        <animate attributeName="offset" values="-1.5; 1.5" dur="1.5s" repeatCount="indefinite" />
-      </stop>
-      <stop offset="100%" stop-color="${bg}">
-        <animate attributeName="offset" values="-1; 2" dur="1.5s" repeatCount="indefinite" />
-      </stop>
-    </linearGradient>
-  </defs>
-  <rect width="${width}" height="${height}" fill="${bg}" />
-  ${avatarShape}
-  ${lines.join('\n  ')}
-</svg>`;
-}
-
-export interface PlaceholderResult {
-    type: string;
-    contentType: string;
-    body: Buffer | string;
-}
-
-export default function placeholder(type: string, query: Record<string, string | undefined>): PlaceholderResult {
-    const opts: PlaceholderOptions = {
-        width: parseSize(query.width, 'width', 800),
-        height: parseSize(query.height, 'height', 600),
-        bg: query.bg,
-        color: query.color,
-        text: query.text,
-        rows: query.rows ? parseInt(query.rows, 10) : undefined,
-        avatar: query.avatar === 'true' || query.avatar === '1',
-    };
-
-    switch (type) {
-        case 'image':
-            return { type, contentType: 'image/png', body: generateImage(opts) };
-        case 'skeleton':
-            return { type, contentType: 'image/svg+xml', body: generateSkeleton(opts) };
-        default:
-            throw new Error('Type must be one of: image, skeleton');
-    }
-}

package/src/routes/delete.ts

@@ -1,72 +0,0 @@
-import { Router, type Request, type Response } from 'express';
-import { chatStorage, ticTacToeStorage } from '../storage/index.js';
-import { error } from '../utils/response.js';
-import { supportsRest } from '../utils/version.js';
-
-const router = Router();
-
-// Forfeit a tic-tac-toe game (REST: DELETE /tic-tac-toe/:game)
-router.delete('/:version/tic-tac-toe/:game', (req: Request, res: Response) => {
-    if (!supportsRest(req)) {
-        error(res, 405, 'DELETE is only supported in v4+.', `${req.version}/tic-tac-toe`);
-        return;
-    }
-
-    const game = req.params.game as string;
-    const { username, session } = (req.body as Record<string, string>) || {};
-
-    if (!username) {
-        error(res, 400, 'Please provide a username (?username={username})');
-        return;
-    }
-    if (!session) {
-        error(res, 400, 'Please provide a valid session ID (&session={ID})');
-        return;
-    }
-
-    try {
-        const result = req.module.tic_tac_toe('forfeit', {
-            username,
-            session,
-            game,
-            storage: ticTacToeStorage,
-        });
-        res.jsonResponse(result);
-    } catch (err) {
-        error(res, 400, (err as Error).message);
-    }
-});
-
-// Clear a private chat (REST: DELETE /chat/:token)
-router.delete('/:version/chat/:token', (req: Request, res: Response) => {
-    if (!supportsRest(req)) {
-        error(res, 405, 'DELETE is only supported in v4+.', `${req.version}/chat`);
-        return;
-    }
-
-    const token = req.params.token as string;
-    const { username, session } = (req.body as Record<string, string>) || {};
-
-    if (!username) {
-        error(res, 400, 'Please provide a username (?username={username})');
-        return;
-    }
-    if (!session) {
-        error(res, 400, 'Please provide a valid session ID (&session={ID})');
-        return;
-    }
-
-    try {
-        const result = req.module.chat('clear', {
-            username,
-            token,
-            session,
-            storage: chatStorage,
-        });
-        res.jsonResponse(result);
-    } catch (err) {
-        error(res, 400, (err as Error).message);
-    }
-});
-
-export default router;

package/src/routes/patch.ts

@@ -1,45 +0,0 @@
-import { Router, type Request, type Response } from 'express';
-import { ticTacToeStorage } from '../storage/index.js';
-import { error } from '../utils/response.js';
-import { supportsRest } from '../utils/version.js';
-
-const router = Router();
-
-// Play a tic-tac-toe move (REST: PATCH /tic-tac-toe/:game)
-router.patch('/:version/tic-tac-toe/:game', (req: Request, res: Response) => {
-    if (!supportsRest(req)) {
-        error(res, 405, 'PATCH is only supported in v4+.', `${req.version}/tic-tac-toe`);
-        return;
-    }
-
-    const game = req.params.game as string;
-    const { username, move, session } = (req.body as Record<string, string>) || {};
-
-    if (!username) {
-        error(res, 400, 'Please provide a username (?username={username})');
-        return;
-    }
-    if (!move) {
-        error(res, 400, 'Please provide a valid move (&move={move})');
-        return;
-    }
-    if (!session) {
-        error(res, 400, 'Please provide a valid session ID (&session={ID})');
-        return;
-    }
-
-    try {
-        const result = req.module.tic_tac_toe('play', {
-            username,
-            move,
-            session,
-            game,
-            storage: ticTacToeStorage,
-        });
-        res.jsonResponse(result);
-    } catch (err) {
-        error(res, 400, (err as Error).message);
-    }
-});
-
-export default router;

package/src/utils/version.ts

@@ -1,5 +0,0 @@
-import type { Request } from 'express';
-
-const REST_VERSIONS = new Set(['v4']);
-
-export const supportsRest = (req: Request): boolean => REST_VERSIONS.has(req.version);

package/tests/unit/geo.test.ts

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

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