r6-data.js 1.5.4 → 1.6.0

package/README.md

@@ -1,6 +1,6 @@
 # r6-data.js — Complete R6 Rainbow Six Siege API Wrapper
 
-**Rainbow Six Siege (R6) API wrapper for Node.js** - Get player stats, operators, maps, ranks, seasons, charms and more. Full TypeScript support included. Last updated Y10S3
+**Rainbow Six Siege (R6) API wrapper** - Get player stats, operators, maps, ranks, seasons, charms and more. Full TypeScript support included. Last updated Y10S3.3
 
   <div align="center">
   <p>
@@ -288,6 +288,46 @@ main();
           }
 ```
 
+## Comparing Player Statistics
+
+The `getPlayerComparisons()` function compares Rainbow Six Siege statistics between multiple players, providing rankings and comparison metrics.
+
+```javascript
+const r6Info = require('r6-data.js');
+
+async function main() {
+  try {
+    const comparison = await r6Info.getPlayerComparisons({
+      players: [
+        { nameOnPlatform: 'Player1', platformType: 'uplay' },
+        { nameOnPlatform: 'Player2', platformType: 'uplay' }
+      ],
+      platform_families: 'pc',
+      board_id: 'ranked', // Optional
+      compareFields: ['kills', 'deaths', 'wins', 'losses'] // Optional
+    });
+
+    console.log('Comparison results:', comparison.comparison_summary.field_comparisons);
+    
+  } catch (error) {
+    console.error('Error during comparison:', error.message);
+  }
+}
+
+main();
+```
+
+### Parameters
+
+- `players`: (Required) Array of player objects with `nameOnPlatform` and `platformType`
+- `platform_families`: (Required) "pc" or "console"
+- `board_id`: (Optional) Game mode filter - "casual", "ranked", etc.
+- `compareFields`: (Optional) Specific stats to compare (default: kills, deaths, wins, losses, etc.)
+
+### Response
+
+Returns comparison data with player stats, field rankings (highest/lowest/average), and metadata including success/failure counts.
+
 ## Creating Discord Webhooks for R6 Stats
 
 The `createDiscordR6Webhook()` function allows you to send Rainbow Six Siege player statistics directly to a Discord channel using webhooks. This creates formatted embeds with player stats that can be customized with various options.

package/index.d.ts

@@ -1,92 +1,152 @@
-// TypeScript declarations for r6-data.js (module-style, no ambient wrapper)
-
-// ----- Types -----
-export type PlatformType = "uplay" | "psn" | "xbl";
-export type PlatformFamily = "pc" | "console";
-export type BoardId = "casual" | "event" | "warmup" | "standard" | "ranked";
-export type RankVersion = "v1" | "v2" | "v3" | "v4" | "v5" | "v6";
-
-export interface AccountInfoParams {
-  nameOnPlatform: string;
-  platformType: PlatformType;
-}
-export interface PlayerStatsParams extends AccountInfoParams {
-  platform_families: PlatformFamily;
-  board_id?: BoardId;
-}
-export interface SeasonalStatsParams extends AccountInfoParams {}
-
-export interface GetMapsParams {
-  name?: string; location?: string; releaseDate?: string; playlists?: string; mapReworked?: boolean;
-}
-export interface GetOperatorsParams {
-  name?: string; safename?: string; realname?: string; birthplace?: string; age?: number; date_of_birth?: string; season_introduced?: string;
-}
-export interface GetSeasonsParams {
-  name?: string; map?: string; operators?: string; weapons?: string;
-}
-export interface GetAttachmentParams {
-  name?: string; style?: string; rarity?: string; availability?: string;
-}
-export interface GetCharmsParams {
-  name?: string; collection?: string; rarity?: string; availability?: string; bundle?: string; season?: string;
-}
-export interface GetWeaponsParams { name?: string; }
-export interface GetUniversalSkinsParams { name?: string; }
-export interface GetRanksParams { version?: RankVersion; min_mmr?: number; max_mmr?: number; }
-
-export interface SearchAllResult {
-  query: string;
-  summary: Record<string, number>;
-  results: {
-    operators: any[]; weapons: any[]; maps: any[]; seasons: any[]; charms: any[]; attachments: any[];
-    [k: string]: any;
-  };
-}
-export interface GameStats {
-  steam?: { concurrent?: number; estimate?: number };
-  crossPlatform?: { totalRegistered?: number; monthlyActive?: number; trendsEstimate?: number; platforms?: { pc?: number; playstation?: number; xbox?: number } };
-  ubisoft?: { onlineEstimate?: number };
-  lastUpdated?: string;
-  [k: string]: any;
-}
-export interface DiscordWebhookOptions {
-  playerName: string; title?: string; message?: string; color?: number; avatarUrl?: string;
-}
-
-// ----- Functions -----
-export function getAccountInfo(params: AccountInfoParams): Promise<any>;
-export function getPlayerStats(params: PlayerStatsParams): Promise<any>;
-export function getSeasonalStats(params: SeasonalStatsParams): Promise<any>;
-export function getServiceStatus(): Promise<any>;
-export function getGameStats(): Promise<GameStats>;
-export function getMaps(params?: GetMapsParams): Promise<any[]>;
-export function getOperators(params?: GetOperatorsParams): Promise<any[]>;
-export function getSeasons(params?: GetSeasonsParams): Promise<any[]>;
-export function getAttachment(params?: GetAttachmentParams): Promise<any[]>;
-export function getCharms(params?: GetCharmsParams): Promise<any[]>;
-export function getWeapons(params?: GetWeaponsParams): Promise<any[]>;
-export function getUniversalSkins(params?: GetUniversalSkinsParams): Promise<any[]>;
-export function getRanks(params?: GetRanksParams): Promise<any[]>;
-export function getSearchAll(query: string): Promise<SearchAllResult>;
-export function createDiscordR6Webhook(webhookUrl: string, playerData: any, options: DiscordWebhookOptions): Promise<any>;
-
-// ----- Default export -----
-declare const r6Data: {
-  getAccountInfo: typeof getAccountInfo;
-  getPlayerStats: typeof getPlayerStats;
-  getSeasonalStats: typeof getSeasonalStats;
-  getServiceStatus: typeof getServiceStatus;
-  getGameStats: typeof getGameStats;
-  getMaps: typeof getMaps;
-  getOperators: typeof getOperators;
-  getSeasons: typeof getSeasons;
-  getAttachment: typeof getAttachment;
-  getCharms: typeof getCharms;
-  getWeapons: typeof getWeapons;
-  getUniversalSkins: typeof getUniversalSkins;
-  getRanks: typeof getRanks;
-  getSearchAll: typeof getSearchAll;
-  createDiscordR6Webhook: typeof createDiscordR6Webhook;
-};
+// TypeScript declarations for r6-data.js (module-style, no ambient wrapper)
+
+// ----- Types -----
+export type PlatformType = "uplay" | "psn" | "xbl";
+export type PlatformFamily = "pc" | "console";
+export type BoardId = "casual" | "event" | "warmup" | "standard" | "ranked";
+export type RankVersion = "v1" | "v2" | "v3" | "v4" | "v5" | "v6";
+
+export interface AccountInfoParams {
+  nameOnPlatform: string;
+  platformType: PlatformType;
+}
+export interface PlayerStatsParams extends AccountInfoParams {
+  platform_families: PlatformFamily;
+  board_id?: BoardId;
+}
+export interface SeasonalStatsParams extends AccountInfoParams {}
+
+export interface PlayerComparisonsParams {
+  players: Array<{
+    nameOnPlatform: string;
+    platformType: PlatformType;
+  }>;
+  platform_families: PlatformFamily;
+  board_id?: BoardId;
+  compareFields?: string[];
+}
+
+export interface GetMapsParams {
+  name?: string; location?: string; releaseDate?: string; playlists?: string; mapReworked?: boolean;
+}
+export interface GetOperatorsParams {
+  name?: string; safename?: string; realname?: string; birthplace?: string; age?: number; date_of_birth?: string; season_introduced?: string;
+}
+export interface GetSeasonsParams {
+  name?: string; map?: string; operators?: string; weapons?: string;
+}
+export interface GetAttachmentParams {
+  name?: string; style?: string; rarity?: string; availability?: string;
+}
+export interface GetCharmsParams {
+  name?: string; collection?: string; rarity?: string; availability?: string; bundle?: string; season?: string;
+}
+export interface GetWeaponsParams { name?: string; }
+export interface GetUniversalSkinsParams { name?: string; }
+export interface GetRanksParams { version?: RankVersion; min_mmr?: number; max_mmr?: number; }
+
+export interface SearchAllResult {
+  query: string;
+  summary: Record<string, number>;
+  results: {
+    operators: any[]; weapons: any[]; maps: any[]; seasons: any[]; charms: any[]; attachments: any[];
+    [k: string]: any;
+  };
+}
+export interface GameStats {
+  steam?: { concurrent?: number; estimate?: number };
+  crossPlatform?: { totalRegistered?: number; monthlyActive?: number; trendsEstimate?: number; platforms?: { pc?: number; playstation?: number; xbox?: number } };
+  ubisoft?: { onlineEstimate?: number };
+  lastUpdated?: string;
+  [k: string]: any;
+}
+export interface DiscordWebhookOptions {
+  playerName: string; title?: string; message?: string; color?: number; avatarUrl?: string;
+}
+
+export interface PlayerComparisonsResult {
+  players: Array<{
+    player: {
+      nameOnPlatform: string;
+      platformType: PlatformType;
+    };
+    stats: any;
+    success: boolean;
+    error?: string;
+  }>;
+  comparison_summary: {
+    field_comparisons: Record<string, {
+      rankings: Array<{
+        player: string;
+        value: number;
+        platform: PlatformType;
+      }>;
+      highest: {
+        player: string;
+        value: number;
+        platform: PlatformType;
+      };
+      lowest: {
+        player: string;
+        value: number;
+        platform: PlatformType;
+      };
+      average: number;
+    }>;
+    rankings: Record<string, any>;
+  };
+  metadata: {
+    total_players: number;
+    successful_fetches: number;
+    failed_fetches: number;
+    platform_families: PlatformFamily;
+    board_id: string;
+    timestamp: string;
+  };
+  errors?: Array<{
+    player: {
+      nameOnPlatform: string;
+      platformType: PlatformType;
+    };
+    error: string;
+  }>;
+}
+
+// ----- Function declarations -----
+export function getAccountInfo(params: AccountInfoParams): Promise<any>;
+export function getPlayerStats(params: PlayerStatsParams): Promise<any>;
+export function getSeasonalStats(params: SeasonalStatsParams): Promise<any>;
+export function getServiceStatus(): Promise<any>;
+export function getGameStats(): Promise<GameStats>;
+export function getMaps(params?: GetMapsParams): Promise<any[]>;
+export function getOperators(params?: GetOperatorsParams): Promise<any[]>;
+export function getSeasons(params?: GetSeasonsParams): Promise<any[]>;
+export function getAttachment(params?: GetAttachmentParams): Promise<any[]>;
+export function getCharms(params?: GetCharmsParams): Promise<any[]>;
+export function getWeapons(params?: GetWeaponsParams): Promise<any[]>;
+export function getUniversalSkins(params?: GetUniversalSkinsParams): Promise<any[]>;
+export function getRanks(params?: GetRanksParams): Promise<any[]>;
+export function getSearchAll(query: string): Promise<SearchAllResult>;
+export function createDiscordR6Webhook(webhookUrl: string, playerData: any, options: DiscordWebhookOptions): Promise<any>;
+export function getPlayerComparisons(params: PlayerComparisonsParams): Promise<PlayerComparisonsResult>;
+
+// ----- Default export -----
+declare const r6Data: {
+  getAccountInfo: typeof getAccountInfo;
+  getPlayerStats: typeof getPlayerStats;
+  getSeasonalStats: typeof getSeasonalStats;
+  getServiceStatus: typeof getServiceStatus;
+  getGameStats: typeof getGameStats;
+  getMaps: typeof getMaps;
+  getOperators: typeof getOperators;
+  getSeasons: typeof getSeasons;
+  getAttachment: typeof getAttachment;
+  getCharms: typeof getCharms;
+  getWeapons: typeof getWeapons;
+  getUniversalSkins: typeof getUniversalSkins;
+  getRanks: typeof getRanks;
+  getSearchAll: typeof getSearchAll;
+  createDiscordR6Webhook: typeof createDiscordR6Webhook;
+  getPlayerComparisons: typeof getPlayerComparisons;
+};
 export default r6Data;

package/index.js

@@ -13,6 +13,7 @@ const getPlayerStats = require('./methods/getPlayerStats');
 const createDiscordR6Webhook = require('./methods/createDiscordR6Webhook');
 const getGameStats = require('./methods/getGameStats');
 const getSeasonalStats = require('./methods/getSeasonalStats');
+const getPlayerComparisons = require('./methods/getPlayerComparisons');
 
 // Export individual functions for named imports
 module.exports = {
@@ -31,6 +32,7 @@ module.exports = {
   createDiscordR6Webhook,
   getGameStats,
   getSeasonalStats,
+  getPlayerComparisons,
 };
 
 // Export individual functions as named exports for ES6 compatibility
@@ -48,4 +50,5 @@ module.exports.getAccountInfo = getAccountInfo;
 module.exports.getPlayerStats = getPlayerStats;
 module.exports.createDiscordR6Webhook = createDiscordR6Webhook;
 module.exports.getGameStats = getGameStats;
-module.exports.getSeasonalStats = getSeasonalStats;
+module.exports.getSeasonalStats = getSeasonalStats;
+module.exports.getPlayerComparisons = getPlayerComparisons;

package/methods/getPlayerComparisons.js

@@ -0,0 +1,234 @@
+const axiosInstance = require('../axiosInstance/axiosInstance');
+const buildUrlAndParams = require('./util');
+
+/**
+ * Compare Rainbow Six Siege player statistics between multiple players
+ * @param {Object} params - Parameters for the request
+ * @param {Array<Object>} params.players - Array of player objects to compare
+ * @param {string} params.players[].nameOnPlatform - Player name on the platform
+ * @param {string} params.players[].platformType - Platform type (uplay, psn, xbl)
+ * @param {string} params.platform_families - Platform families: "pc" or "console"
+ * @param {string} [params.board_id] - Game mode to filter stats (casual, event, warmup, standard, ranked)
+ * @param {Array<string>} [params.compareFields] - Specific fields to compare (e.g., ['kills', 'deaths', 'wins', 'losses'])
+ * @returns {Promise<Object>} - Comparison results with player statistics and comparison metrics
+ */
+async function getPlayerComparisons({ players, platform_families, board_id, compareFields } = {}) {
+  try {
+    // Validate required parameters
+    if (!players || !Array.isArray(players) || players.length < 2) {
+      throw new Error('At least 2 players are required for comparison');
+    }
+
+    if (!platform_families) {
+      throw new Error('Missing required parameter: platform_families');
+    }
+
+    // Validate each player object
+    for (let i = 0; i < players.length; i++) {
+      const player = players[i];
+      if (!player.nameOnPlatform || !player.platformType) {
+        throw new Error(`Player ${i + 1} is missing required fields: nameOnPlatform, platformType`);
+      }
+    }
+
+    // Validate board_id if provided
+    if (board_id && !['casual', 'event', 'warmup', 'standard', 'ranked'].includes(board_id)) {
+      throw new Error('Invalid board_id. Must be one of: casual, event, warmup, standard, ranked');
+    }
+
+    // Fetch stats for each player
+    const playerStats = [];
+    const errors = [];
+
+    for (const player of players) {
+      try {
+        const params = {
+          type: 'stats',
+          nameOnPlatform: player.nameOnPlatform,
+          platformType: player.platformType,
+          platform_families
+        };
+
+        if (board_id) {
+          params.board_id = board_id;
+        }
+
+        const url = buildUrlAndParams('/stats', params);
+        const response = await axiosInstance.get(url);
+
+        if (response.data && 
+            response.data.platform_families_full_profiles && 
+            response.data.platform_families_full_profiles.length > 0) {
+          
+          // Filter by board_id if specified
+          if (board_id && response.data.platform_families_full_profiles) {
+            response.data.platform_families_full_profiles.forEach(profile => {
+              if (profile.board_ids_full_profiles) {
+                profile.board_ids_full_profiles = profile.board_ids_full_profiles.filter(
+                  board => board.board_id === board_id
+                );
+              }
+            });
+          }
+
+          playerStats.push({
+            player: player,
+            stats: response.data,
+            success: true
+          });
+        } else {
+          playerStats.push({
+            player: player,
+            stats: null,
+            success: false,
+            error: 'No stats found for player'
+          });
+        }
+      } catch (error) {
+        errors.push({
+          player: player,
+          error: error.message
+        });
+        playerStats.push({
+          player: player,
+          stats: null,
+          success: false,
+          error: error.message
+        });
+      }
+    }
+
+    // Generate comparison results
+    const comparison = {
+      players: playerStats,
+      comparison_summary: generateComparisonSummary(playerStats, compareFields),
+      metadata: {
+        total_players: players.length,
+        successful_fetches: playerStats.filter(p => p.success).length,
+        failed_fetches: playerStats.filter(p => !p.success).length,
+        platform_families,
+        board_id: board_id || 'all',
+        timestamp: new Date().toISOString()
+      }
+    };
+
+    if (errors.length > 0) {
+      comparison.errors = errors;
+    }
+
+    return comparison;
+
+  } catch (error) {
+    console.error('Error during the getPlayerComparisons request:', error.message);
+    if (error.response && error.response.status === 401) {
+      throw new Error('Authentication error');
+    }
+    throw error;
+  }
+}
+
+/**
+ * Generate comparison summary between players
+ * @param {Array} playerStats - Array of player statistics
+ * @param {Array} compareFields - Fields to compare
+ * @returns {Object} - Comparison summary
+ */
+function generateComparisonSummary(playerStats, compareFields) {
+  const successfulStats = playerStats.filter(p => p.success && p.stats);
+  
+  if (successfulStats.length < 2) {
+    return {
+      message: 'Not enough valid player data for comparison',
+      valid_players: successfulStats.length
+    };
+  }
+
+  const summary = {
+    field_comparisons: {},
+    rankings: {}
+  };
+
+  // Default fields to compare if none specified
+  const fieldsToCompare = compareFields || [
+    'kills', 'deaths', 'wins', 'losses', 'matches_played', 
+    'time_played', 'headshots', 'melee_kills', 'revives'
+  ];
+
+  // Extract and compare stats
+  fieldsToCompare.forEach(field => {
+    const fieldData = [];
+    
+    successfulStats.forEach(playerStat => {
+      const stats = extractFieldFromStats(playerStat.stats, field);
+      if (stats !== null) {
+        fieldData.push({
+          player: playerStat.player.nameOnPlatform,
+          value: stats,
+          platform: playerStat.player.platformType
+        });
+      }
+    });
+
+    if (fieldData.length > 0) {
+      // Sort by value (descending)
+      fieldData.sort((a, b) => b.value - a.value);
+      
+      summary.field_comparisons[field] = {
+        rankings: fieldData,
+        highest: fieldData[0],
+        lowest: fieldData[fieldData.length - 1],
+        average: fieldData.reduce((sum, item) => sum + item.value, 0) / fieldData.length
+      };
+    }
+  });
+
+  return summary;
+}
+
+/**
+ * Extract a specific field value from player stats
+ * @param {Object} stats - Player statistics object
+ * @param {string} field - Field name to extract
+ * @returns {number|null} - Field value or null if not found
+ */
+function extractFieldFromStats(stats, field) {
+  try {
+    if (!stats.platform_families_full_profiles || stats.platform_families_full_profiles.length === 0) {
+      return null;
+    }
+
+    const profile = stats.platform_families_full_profiles[0];
+    if (!profile.board_ids_full_profiles || profile.board_ids_full_profiles.length === 0) {
+      return null;
+    }
+
+    const boardProfile = profile.board_ids_full_profiles[0];
+    if (!boardProfile.full_profiles || boardProfile.full_profiles.length === 0) {
+      return null;
+    }
+
+    const fullProfile = boardProfile.full_profiles[0];
+    
+    // Map common field names to actual API field names
+    const fieldMapping = {
+      'kills': 'kills',
+      'deaths': 'deaths', 
+      'wins': 'wins',
+      'losses': 'losses',
+      'matches_played': 'matches_played',
+      'time_played': 'time_played',
+      'headshots': 'headshots',
+      'melee_kills': 'melee_kills',
+      'revives': 'revives'
+    };
+
+    const actualField = fieldMapping[field] || field;
+    return fullProfile[actualField] || 0;
+
+  } catch (error) {
+    console.warn(`Error extracting field ${field}:`, error.message);
+    return null;
+  }
+}
+
+module.exports = getPlayerComparisons;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "r6-data.js",
-  "version": "1.5.4",
+  "version": "1.6.0",
   "description": "R6 (Rainbow Six Siege) API wrapper for player stats, operators, maps, ranks, seasons, and game data. Typescript support. Last Updated Y10S3",
   "main": "index.js",
   "module": "index.js",
@@ -59,8 +59,8 @@
     "ms": "^2.1.3"
   },
   "devDependencies": {
-    "@types/node": "^24.8.0",
-    "eslint": "^9.37.0",
+    "@types/node": "^24.9.1",
+    "eslint": "^9.38.0",
     "typescript": "^5.9.3"
   }
 }