@20syldev/api 3.4.0 → 3.4.1

package/modules/v3/tic_tac_toe.js

@@ -1,167 +1,167 @@
-import { randomBytes } from 'crypto';
-
-/**
- * Manages a Tic-Tac-Toe game session
- *
- * @param {string} action - The action to perform ('play' or 'fetch')
- * @param {Object} params - The parameters for the action
- * @returns {Object} - The result of the action
- * @throws {Error} - If parameters are invalid
- */
-export default function tic_tac_toe(action, params = {}) {
-    // In-memory storage
-    const storage = params.storage || {};
-
-    // Initialize storage
-    storage.games ??= {};
-    storage.sessions ??= {};
-    storage.rateLimits ??= {};
-
-    // Reference the storage properties
-    const { games, sessions, rateLimits } = storage;
-
-    // Input validation for common parameters
-    if (!params.username) throw new Error('Please provide a username');
-
-    const u = params.username.toLowerCase();
-    const now = Date.now();
-
-    // Rate limiting
-    rateLimits[u] = (rateLimits[u] || []).filter(ts => now - ts < 10000);
-    if (rateLimits[u].length > 50) {
-        const remainingTime = Math.ceil((rateLimits[u][0] + 10000 - now) / 1000);
-        throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
-    }
-    rateLimits[u].push(now);
-
-    // Handle different actions
-    if (action === 'play') {
-        return playMove(params, games, sessions, u, now);
-    } else if (action === 'fetch') {
-        return fetchGame(params, games, u);
-    } else {
-        throw new Error('Invalid action. Use "play" or "fetch"');
-    }
-}
-
-/**
- * Process a player's move
- */
-function playMove(params, games, sessions, u, now) {
-    const { move, session, game } = params;
-    const validMoves = ['1-1', '1-2', '1-3', '2-1', '2-2', '2-3', '3-1', '3-2', '3-3'];
-
-    // Input validation for play action
-    if (!move) throw new Error('Please provide a valid move');
-    if (!session) throw new Error('Please provide a valid session ID');
-    if (!game) throw new Error('Please provide a valid game ID');
-    if (!validMoves.includes(move)) throw new Error('Invalid move. Please provide a valid move (e.g., 1-1, 2-2, 3-3).');
-
-    // Session validation
-    if (sessions[u] && sessions[u].user !== session) {
-        throw new Error('Session ID mismatch');
-    }
-
-    // Initialize game if needed
-    games[game] = games[game] || [];
-
-    // Check if game is full
-    const players = [...new Set(games[game].map(play => play.username))];
-    if (players.length >= 2 && !players.includes(params.username)) {
-        throw new Error('Game is full, you can only watch.');
-    }
-
-    // Check if it's player's turn
-    if (games[game].length > 0 && games[game][games[game].length - 1].username === params.username) {
-        throw new Error('Please wait for the other player to make a move.');
-    }
-
-    // Check if move is already made
-    if (games[game].some(play => play.move === move)) {
-        throw new Error('Move already made. Please choose a different move.');
-    }
-
-    // Add move to game
-    const play = { username: params.username, move, session };
-    games[game].push(play);
-
-    // Check game result
-    const result = checkGame(games[game]);
-    if (result.winner || result.tie) {
-        setTimeout(() => delete games[game], 600000);
-        return {
-            message: `Move sent successfully. ${result.winner ? result.winner + ' wins. ' + result.loser + ' loses.' : 'It\'s a tie.'}`,
-            ...result
-        };
-    }
-
-    // Set cleanup timeout
-    setTimeout(() => delete games[game], 3600000);
-
-    // Update session
-    sessions[u] = sessions[u] || { user: session, last: now };
-    sessions[u].last = now;
-    setTimeout(() => { if (now - sessions[u].last >= 3600000) delete sessions[u]; }, 3600000);
-
-    return { message: 'Move sent successfully' };
-}
-
-/**
- * Fetch a game state
- */
-function fetchGame(params, games, u) {
-    const ID = params.game || generateGameId();
-
-    // Initialize game if needed
-    if (!games[ID]) games[ID] = [];
-
-    const data = games[ID];
-    const last = data.length ? data[data.length - 1].username : null;
-    const players = [...new Set(data.map(p => p.username))];
-    const turn = players.find(p => p !== last);
-    const result = data.length ? checkGame(data) : {};
-
-    return { game: data, turn, ID, ...result };
-}
-
-/**
- * Generate a random game ID
- */
-function generateGameId() {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-    return Array.from(randomBytes(5)).map(b => chars[b % chars.length]).join('');
-}
-
-/**
- * Check the game result
- */
-function checkGame(moves) {
-    let board = Array(3).fill().map(() => Array(3).fill(null));
-    let playerSymbols = {};
-    let playersOrder = [];
-
-    moves.forEach(({ username, move }) => {
-        if (!playerSymbols[username]) {
-            playersOrder.push(username);
-            playerSymbols[username] = playersOrder.length === 1 ? 'X' : 'O';
-        }
-        let [row, col] = move.split('-').map(Number);
-        board[row - 1][col - 1] = playerSymbols[username];
-    });
-
-    const checkWinner = (symbol) => {
-        for (let i = 0; i < 3; i++) {
-            if (board[i][0] === symbol && board[i][1] === symbol && board[i][2] === symbol) return true;
-            if (board[0][i] === symbol && board[1][i] === symbol && board[2][i] === symbol) return true;
-        }
-        if (board[0][0] === symbol && board[1][1] === symbol && board[2][2] === symbol) return true;
-        if (board[0][2] === symbol && board[1][1] === symbol && board[2][0] === symbol) return true;
-        return false;
-    };
-
-    let winner = Object.keys(playerSymbols).find(player => checkWinner(playerSymbols[player]));
-    let isTie = !winner && moves.length === 9;
-    let loser = winner && playersOrder.length === 2 ? playersOrder.find(player => player !== winner) : null;
-
-    return { winner, loser, tie: isTie };
+import { randomBytes } from 'crypto';
+
+/**
+ * Manages a Tic-Tac-Toe game session
+ *
+ * @param {string} action - The action to perform ('play' or 'fetch')
+ * @param {Object} params - The parameters for the action
+ * @returns {Object} - The result of the action
+ * @throws {Error} - If parameters are invalid
+ */
+export default function tic_tac_toe(action, params = {}) {
+    // In-memory storage
+    const storage = params.storage || {};
+
+    // Initialize storage
+    storage.games ??= {};
+    storage.sessions ??= {};
+    storage.rateLimits ??= {};
+
+    // Reference the storage properties
+    const { games, sessions, rateLimits } = storage;
+
+    // Input validation for common parameters
+    if (!params.username) throw new Error('Please provide a username');
+
+    const u = params.username.toLowerCase();
+    const now = Date.now();
+
+    // Rate limiting
+    rateLimits[u] = (rateLimits[u] || []).filter(ts => now - ts < 10000);
+    if (rateLimits[u].length > 50) {
+        const remainingTime = Math.ceil((rateLimits[u][0] + 10000 - now) / 1000);
+        throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
+    }
+    rateLimits[u].push(now);
+
+    // Handle different actions
+    if (action === 'play') {
+        return playMove(params, games, sessions, u, now);
+    } else if (action === 'fetch') {
+        return fetchGame(params, games, u);
+    } else {
+        throw new Error('Invalid action. Use "play" or "fetch"');
+    }
+}
+
+/**
+ * Process a player's move
+ */
+function playMove(params, games, sessions, u, now) {
+    const { move, session, game } = params;
+    const validMoves = ['1-1', '1-2', '1-3', '2-1', '2-2', '2-3', '3-1', '3-2', '3-3'];
+
+    // Input validation for play action
+    if (!move) throw new Error('Please provide a valid move');
+    if (!session) throw new Error('Please provide a valid session ID');
+    if (!game) throw new Error('Please provide a valid game ID');
+    if (!validMoves.includes(move)) throw new Error('Invalid move. Please provide a valid move (e.g., 1-1, 2-2, 3-3).');
+
+    // Session validation
+    if (sessions[u] && sessions[u].user !== session) {
+        throw new Error('Session ID mismatch');
+    }
+
+    // Initialize game if needed
+    games[game] = games[game] || [];
+
+    // Check if game is full
+    const players = [...new Set(games[game].map(play => play.username))];
+    if (players.length >= 2 && !players.includes(params.username)) {
+        throw new Error('Game is full, you can only watch.');
+    }
+
+    // Check if it's player's turn
+    if (games[game].length > 0 && games[game][games[game].length - 1].username === params.username) {
+        throw new Error('Please wait for the other player to make a move.');
+    }
+
+    // Check if move is already made
+    if (games[game].some(play => play.move === move)) {
+        throw new Error('Move already made. Please choose a different move.');
+    }
+
+    // Add move to game
+    const play = { username: params.username, move, session };
+    games[game].push(play);
+
+    // Check game result
+    const result = checkGame(games[game]);
+    if (result.winner || result.tie) {
+        setTimeout(() => delete games[game], 600000);
+        return {
+            message: `Move sent successfully. ${result.winner ? result.winner + ' wins. ' + result.loser + ' loses.' : 'It\'s a tie.'}`,
+            ...result
+        };
+    }
+
+    // Set cleanup timeout
+    setTimeout(() => delete games[game], 3600000);
+
+    // Update session
+    sessions[u] = sessions[u] || { user: session, last: now };
+    sessions[u].last = now;
+    setTimeout(() => { if (now - sessions[u].last >= 3600000) delete sessions[u]; }, 3600000);
+
+    return { message: 'Move sent successfully' };
+}
+
+/**
+ * Fetch a game state
+ */
+function fetchGame(params, games, u) {
+    const ID = params.game || generateGameId();
+
+    // Initialize game if needed
+    if (!games[ID]) games[ID] = [];
+
+    const data = games[ID];
+    const last = data.length ? data[data.length - 1].username : null;
+    const players = [...new Set(data.map(p => p.username))];
+    const turn = players.find(p => p !== last);
+    const result = data.length ? checkGame(data) : {};
+
+    return { game: data, turn, ID, ...result };
+}
+
+/**
+ * Generate a random game ID
+ */
+function generateGameId() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    return Array.from(randomBytes(5)).map(b => chars[b % chars.length]).join('');
+}
+
+/**
+ * Check the game result
+ */
+function checkGame(moves) {
+    let board = Array(3).fill().map(() => Array(3).fill(null));
+    let playerSymbols = {};
+    let playersOrder = [];
+
+    moves.forEach(({ username, move }) => {
+        if (!playerSymbols[username]) {
+            playersOrder.push(username);
+            playerSymbols[username] = playersOrder.length === 1 ? 'X' : 'O';
+        }
+        let [row, col] = move.split('-').map(Number);
+        board[row - 1][col - 1] = playerSymbols[username];
+    });
+
+    const checkWinner = (symbol) => {
+        for (let i = 0; i < 3; i++) {
+            if (board[i][0] === symbol && board[i][1] === symbol && board[i][2] === symbol) return true;
+            if (board[0][i] === symbol && board[1][i] === symbol && board[2][i] === symbol) return true;
+        }
+        if (board[0][0] === symbol && board[1][1] === symbol && board[2][2] === symbol) return true;
+        if (board[0][2] === symbol && board[1][1] === symbol && board[2][0] === symbol) return true;
+        return false;
+    };
+
+    let winner = Object.keys(playerSymbols).find(player => checkWinner(playerSymbols[player]));
+    let isTie = !winner && moves.length === 9;
+    let loser = winner && playersOrder.length === 2 ? playersOrder.find(player => player !== winner) : null;
+
+    return { winner, loser, tie: isTie };
 }

package/modules/v3/time.js

@@ -1,87 +1,87 @@
-/**
- * Generate time information based on specified parameters.
- *
- * @param {string} type - The type of time information ('live' or 'random')
- * @param {string} start - Start date for random generation (ISO format)
- * @param {string} end - End date for random generation (ISO format)
- * @param {string} format - Specific time format to return
- * @param {string} timezone - Timezone to use
- * @returns {object} - Time information in various formats
- * @throws {Error} - If inputs are invalid
- */
-export default function time(type = 'live', start, end, format, timezone) {
-    const validFormats = [
-        'iso', 'utc', 'timestamp', 'locale', 'date', 'time',
-        'year', 'month', 'day', 'hour', 'minute', 'second',
-        'ms', 'dayOfWeek', 'dayOfYear', 'weekNumber',
-        'timezone', 'timezoneOffset'
-    ];
-
-    const validTimezones = [
-        'UTC', 'America/New_York', 'Europe/Paris',
-        'Asia/Tokyo', 'Australia/Sydney'
-    ];
-
-    // Input validation
-    if (type !== 'live' && type !== 'random') {
-        throw new Error('Please provide a valid type (live or random)');
-    }
-
-    if (start && !Date.parse(start)) {
-        throw new Error('Please provide a valid start date (YYYY-MM-DD)');
-    }
-
-    if (end && !Date.parse(end)) {
-        throw new Error('Please provide a valid end date (YYYY-MM-DD)');
-    }
-
-    if (format && !validFormats.includes(format)) {
-        throw new Error(`Please provide a valid format. Options: ${validFormats.join(', ')}`);
-    }
-
-    if (timezone && !validTimezones.includes(timezone)) {
-        throw new Error(`Please provide a valid timezone. Options: ${validTimezones.join(', ')}`);
-    }
-
-    // Helper function to get all time formats for a date
-    const getTimeFormats = (date, tz) => {
-        return {
-            iso: date.toISOString(),
-            utc: date.toUTCString(),
-            timestamp: date.getTime(),
-            locale: date.toLocaleString('en-US', { timeZone: tz, timeZoneName: 'long' }),
-            date: date.toLocaleDateString('en-US', { timeZone: tz }),
-            time: date.toLocaleTimeString('en-US', { timeZone: tz }),
-            year: date.getFullYear(),
-            month: date.getMonth() + 1,
-            day: date.getDate(),
-            hour: date.getHours(),
-            minute: date.getMinutes(),
-            second: date.getSeconds(),
-            ms: date.getMilliseconds(),
-            dayOfWeek: date.getDay(),
-            dayOfYear: Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 86400000),
-            weekNumber: Math.ceil((((date - new Date(date.getFullYear(), 0, 0)) / 86400000) + 1) / 7),
-            timezone: tz,
-            timezoneOffset: date.getTimezoneOffset()
-        };
-    };
-
-    // Generate time information based on type
-    if (type === 'random') {
-        const startDate = start ? new Date(start).getTime() : new Date('1900-01-01').getTime();
-        const endDate = end ? new Date(end).getTime() : new Date('2100-12-31').getTime();
-        const randomDate = new Date(startDate + Math.random() * (endDate - startDate));
-        const tz = timezone || validTimezones[Math.floor(Math.random() * validTimezones.length)];
-        const formats = getTimeFormats(randomDate, tz);
-
-        return format ? { date: formats[format] } : formats;
-    }
-
-    // Live time information
-    const now = new Date();
-    const tz = timezone || 'UTC';
-    const formats = getTimeFormats(now, tz);
-
-    return format ? { date: formats[format] } : formats;
+/**
+ * Generate time information based on specified parameters.
+ *
+ * @param {string} type - The type of time information ('live' or 'random')
+ * @param {string} start - Start date for random generation (ISO format)
+ * @param {string} end - End date for random generation (ISO format)
+ * @param {string} format - Specific time format to return
+ * @param {string} timezone - Timezone to use
+ * @returns {object} - Time information in various formats
+ * @throws {Error} - If inputs are invalid
+ */
+export default function time(type = 'live', start, end, format, timezone) {
+    const validFormats = [
+        'iso', 'utc', 'timestamp', 'locale', 'date', 'time',
+        'year', 'month', 'day', 'hour', 'minute', 'second',
+        'ms', 'dayOfWeek', 'dayOfYear', 'weekNumber',
+        'timezone', 'timezoneOffset'
+    ];
+
+    const validTimezones = [
+        'UTC', 'America/New_York', 'Europe/Paris',
+        'Asia/Tokyo', 'Australia/Sydney'
+    ];
+
+    // Input validation
+    if (type !== 'live' && type !== 'random') {
+        throw new Error('Please provide a valid type (live or random)');
+    }
+
+    if (start && !Date.parse(start)) {
+        throw new Error('Please provide a valid start date (YYYY-MM-DD)');
+    }
+
+    if (end && !Date.parse(end)) {
+        throw new Error('Please provide a valid end date (YYYY-MM-DD)');
+    }
+
+    if (format && !validFormats.includes(format)) {
+        throw new Error(`Please provide a valid format. Options: ${validFormats.join(', ')}`);
+    }
+
+    if (timezone && !validTimezones.includes(timezone)) {
+        throw new Error(`Please provide a valid timezone. Options: ${validTimezones.join(', ')}`);
+    }
+
+    // Helper function to get all time formats for a date
+    const getTimeFormats = (date, tz) => {
+        return {
+            iso: date.toISOString(),
+            utc: date.toUTCString(),
+            timestamp: date.getTime(),
+            locale: date.toLocaleString('en-US', { timeZone: tz, timeZoneName: 'long' }),
+            date: date.toLocaleDateString('en-US', { timeZone: tz }),
+            time: date.toLocaleTimeString('en-US', { timeZone: tz }),
+            year: date.getFullYear(),
+            month: date.getMonth() + 1,
+            day: date.getDate(),
+            hour: date.getHours(),
+            minute: date.getMinutes(),
+            second: date.getSeconds(),
+            ms: date.getMilliseconds(),
+            dayOfWeek: date.getDay(),
+            dayOfYear: Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 86400000),
+            weekNumber: Math.ceil((((date - new Date(date.getFullYear(), 0, 0)) / 86400000) + 1) / 7),
+            timezone: tz,
+            timezoneOffset: date.getTimezoneOffset()
+        };
+    };
+
+    // Generate time information based on type
+    if (type === 'random') {
+        const startDate = start ? new Date(start).getTime() : new Date('1900-01-01').getTime();
+        const endDate = end ? new Date(end).getTime() : new Date('2100-12-31').getTime();
+        const randomDate = new Date(startDate + Math.random() * (endDate - startDate));
+        const tz = timezone || validTimezones[Math.floor(Math.random() * validTimezones.length)];
+        const formats = getTimeFormats(randomDate, tz);
+
+        return format ? { date: formats[format] } : formats;
+    }
+
+    // Live time information
+    const now = new Date();
+    const tz = timezone || 'UTC';
+    const formats = getTimeFormats(now, tz);
+
+    return format ? { date: formats[format] } : formats;
 }

package/modules/v3/token.js

@@ -1,48 +1,48 @@
-import { randomBytes } from 'crypto';
-import { v4 } from 'uuid';
-
-/**
- * Generate a random token of specified length and type.
- *
- * @param {number} len - Length of the token
- * @param {string} type - Type of token to generate
- * @returns {string} - The generated token
- * @throws {Error} - If inputs are invalid
- */
-export default function token(len, type = 'alphanum') {
-    // Input validation
-    if (isNaN(len) || len < 12) {
-        throw new Error('Length must be a number greater than or equal to 12');
-    }
-
-    if (len > 4096) {
-        throw new Error('Length cannot exceed 4096');
-    }
-
-    // Helper function to generate token from character set
-    const genToken = (chars, length) => {
-        return Array.from({ length }, () => {
-            return chars[Math.floor(Math.random() * chars.length)];
-        }).join('');
-    }
-
-    // Token type definitions
-    const tokenTypes = {
-        alpha: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', len),
-        alphanum: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', len),
-        base64: () => randomBytes(Math.ceil(len * 0.75)).toString('base64').slice(0, len),
-        hex: () => randomBytes(Math.ceil(len * 0.5)).toString('hex').slice(0, len),
-        num: () => genToken('0123456789', len),
-        punct: () => genToken('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~', len),
-        urlsafe: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_', len),
-        uuid: () => v4().replace(/-/g, '').slice(0, len)
-    };
-
-    // Generate token based on type or default to alphanum
-    if (!tokenTypes[type.toLowerCase()]) {
-        throw new Error(`Invalid token type. Valid types: ${Object.keys(tokenTypes).join(', ')}`);
-    }
-
-    // Generate token based on type or default to alphanum
-    return (tokenTypes[type.toLowerCase()] || tokenTypes.alphanum)();
+import { randomBytes } from 'crypto';
+import { v4 } from 'uuid';
+
+/**
+ * Generate a random token of specified length and type.
+ *
+ * @param {number} len - Length of the token
+ * @param {string} type - Type of token to generate
+ * @returns {string} - The generated token
+ * @throws {Error} - If inputs are invalid
+ */
+export default function token(len, type = 'alphanum') {
+    // Input validation
+    if (isNaN(len) || len < 12) {
+        throw new Error('Length must be a number greater than or equal to 12');
+    }
+
+    if (len > 4096) {
+        throw new Error('Length cannot exceed 4096');
+    }
+
+    // Helper function to generate token from character set
+    const genToken = (chars, length) => {
+        return Array.from({ length }, () => {
+            return chars[Math.floor(Math.random() * chars.length)];
+        }).join('');
+    }
+
+    // Token type definitions
+    const tokenTypes = {
+        alpha: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', len),
+        alphanum: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', len),
+        base64: () => randomBytes(Math.ceil(len * 0.75)).toString('base64').slice(0, len),
+        hex: () => randomBytes(Math.ceil(len * 0.5)).toString('hex').slice(0, len),
+        num: () => genToken('0123456789', len),
+        punct: () => genToken('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~', len),
+        urlsafe: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_', len),
+        uuid: () => v4().replace(/-/g, '').slice(0, len)
+    };
+
+    // Generate token based on type or default to alphanum
+    if (!tokenTypes[type.toLowerCase()]) {
+        throw new Error(`Invalid token type. Valid types: ${Object.keys(tokenTypes).join(', ')}`);
+    }
+
+    // Generate token based on type or default to alphanum
+    return (tokenTypes[type.toLowerCase()] || tokenTypes.alphanum)();
 }