@timmsy/riftjs 2.1.0 → 3.1.0

package/dist/index.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataDragon = exports.RiotAPI = void 0;
+require("dotenv/config");
+const axios_1 = __importDefault(require("axios"));
+const datadragon_1 = __importDefault(require("./endpoints/datadragon"));
+const riot_1 = __importDefault(require("./endpoints/riot"));
+const regionMap = {
+    BR1: { platform: 'br1.api.riotgames.com', shard: 'americas.api.riotgames.com' },
+    EUN1: { platform: 'eun1.api.riotgames.com', shard: 'europe.api.riotgames.com' },
+    EUW1: { platform: 'euw1.api.riotgames.com', shard: 'europe.api.riotgames.com' },
+    JP1: { platform: 'jp1.api.riotgames.com', shard: 'asia.api.riotgames.com' },
+    KR: { platform: 'kr.api.riotgames.com', shard: 'asia.api.riotgames.com' },
+    LA1: { platform: 'la1.api.riotgames.com', shard: 'americas.api.riotgames.com' },
+    LA2: { platform: 'la2.api.riotgames.com', shard: 'americas.api.riotgames.com' },
+    NA1: { platform: 'na1.api.riotgames.com', shard: 'americas.api.riotgames.com' },
+    OC1: { platform: 'oc1.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    TR1: { platform: 'tr1.api.riotgames.com', shard: 'europe.api.riotgames.com' },
+    RU: { platform: 'ru.api.riotgames.com', shard: 'europe.api.riotgames.com' },
+    PH2: { platform: 'ph2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    SG2: { platform: 'sg2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    TH2: { platform: 'th2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    TW2: { platform: 'tw2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    VN2: { platform: 'vn2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+};
+const parseRegion = (region) => {
+    // Maintainer note (Timmsy): fail fast on bad region input so routing bugs are obvious immediately.
+    const upper = region.toUpperCase();
+    if (!regionMap[upper])
+        throw new Error(`Invalid region: ${region}`);
+    return upper;
+};
+class RiotAPI {
+    constructor() {
+        this._handleError = (error) => {
+            if (axios_1.default.isAxiosError(error)) {
+                if (error.response) {
+                    const status = error.response.status;
+                    const data = error.response.data;
+                    return new Error(`API error ${status}: ${data?.status?.message || 'Unknown error'}`);
+                }
+                if (error.request) {
+                    return new Error('No response received from the server');
+                }
+                return new Error(`Request error: ${error.message}`);
+            }
+            if (error instanceof Error) {
+                return new Error(`Request error: ${error.message}`);
+            }
+            return new Error('Request error: Unknown error');
+        };
+        this.apiKey = process.env.RIOT_API_KEY || '';
+        if (!this.apiKey)
+            throw new Error('RIOT_API_KEY is required in .env');
+        this.region = parseRegion(process.env.REGION || 'EUW1');
+        this.client = axios_1.default.create({
+            headers: { 'X-Riot-Token': this.apiKey },
+        });
+        // Maintainer note (Timmsy): keep endpoint methods attached here so the class API stays flat for consumers.
+        Object.assign(this, (0, riot_1.default)({
+            client: this.client,
+            defaultRegion: this.region,
+            regionMap,
+            handleError: this._handleError,
+        }));
+    }
+}
+exports.RiotAPI = RiotAPI;
+class DataDragon {
+    constructor(version = null, locale = 'en_US') {
+        this.version = version;
+        this.locale = locale;
+        this.baseURL = null;
+        this.baseURLPromise = null;
+        Object.assign(this, (0, datadragon_1.default)(() => this.resolveBaseURL()));
+    }
+    async resolveBaseURL() {
+        if (this.baseURL)
+            return this.baseURL;
+        if (this.baseURLPromise)
+            return this.baseURLPromise;
+        // Maintainer note (Timmsy): share one in-flight resolver to avoid duplicate version requests under concurrency.
+        this.baseURLPromise = (async () => {
+            if (!this.version) {
+                const response = await axios_1.default.get('https://ddragon.leagueoflegends.com/api/versions.json');
+                const latestVersion = Array.isArray(response.data) ? response.data[0] : null;
+                if (!latestVersion) {
+                    throw new Error('Could not resolve latest Data Dragon version');
+                }
+                this.version = latestVersion;
+            }
+            this.baseURL = `https://ddragon.leagueoflegends.com/cdn/${this.version}/data/${this.locale}`;
+            return this.baseURL;
+        })();
+        try {
+            return await this.baseURLPromise;
+        }
+        finally {
+            this.baseURLPromise = null;
+        }
+    }
+}
+exports.DataDragon = DataDragon;

package/dist/test-endpoints.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/{test-endpoints.js → dist/test-endpoints.js}

@@ -1,71 +1,61 @@
-require('dotenv').config();
-const { RiotAPI, DataDragon } = require('./index');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const index_1 = require("./index");
 async function run() {
     const riotId = process.env.TEST_RIOT_ID;
     const tagLine = process.env.TEST_TAG_LINE;
-    const dd = new DataDragon();
-
+    const dd = new index_1.DataDragon();
     if (process.env.RIOT_API_KEY && riotId) {
-        const riot = new RiotAPI();
+        const riot = new index_1.RiotAPI();
         const account = await riot.getAccountByRiotId(riotId, tagLine);
         console.log('[PASS] getAccountByRiotId:', account.puuid);
-
-        const summoner = await riot.getSummonerByPuuid(account.puuid);
+        const puuid = String(account.puuid || '');
+        const summoner = await riot.getSummonerByPuuid(puuid);
         console.log('[PASS] getSummonerByPuuid:', {
             puuid: summoner.puuid,
             summonerLevel: summoner.summonerLevel,
         });
-
-        const rank = await riot.getRankByPuuid(account.puuid);
+        const rank = await riot.getRankByPuuid(puuid);
         console.log('[PASS] getRankByPuuid:', {
-            solo: rank.solo ? `${rank.solo.tier} ${rank.solo.rank} | ${rank.solo.leaguePoints} LP | ${rank.solo.wins}W-${rank.solo.losses}L | ${rank.solo.winRate}% WR` : null,
-            flex: rank.flex ? `${rank.flex.tier} ${rank.flex.rank} | ${rank.flex.leaguePoints} LP | ${rank.flex.wins}W-${rank.flex.losses}L | ${rank.flex.winRate}% WR` : null,
+            solo: rank.solo
+                ? `${rank.solo.tier} ${rank.solo.rank} | ${rank.solo.leaguePoints} LP | ${rank.solo.wins}W-${rank.solo.losses}L | ${rank.solo.winRate}% WR`
+                : null,
+            flex: rank.flex
+                ? `${rank.flex.tier} ${rank.flex.rank} | ${rank.flex.leaguePoints} LP | ${rank.flex.wins}W-${rank.flex.losses}L | ${rank.flex.winRate}% WR`
+                : null,
         });
-
-        const matchIds = await riot.getMatchlistByPuuid(account.puuid, { start: 0, count: 3 });
+        const matchIds = await riot.getMatchlistByPuuid(puuid, { start: 0, count: 3 });
         console.log('[PASS] getMatchlistByPuuid:', matchIds.length, 'match ids');
-
         if (matchIds.length > 0) {
             const match = await riot.getMatchById(matchIds[0]);
-            console.log('[PASS] getMatchById:', match.metadata.matchId);
-
+            console.log('[PASS] getMatchById:', match.metadata?.matchId);
             const timeline = await riot.getMatchTimelineById(matchIds[0]);
-            console.log('[PASS] getMatchTimelineById:', timeline.metadata.matchId);
-
-            const allMatchIds = await riot.getMatchlistByPuuidAll(
-                account.puuid,
-                { start: 0 },
-                undefined,
-                { maxMatches: 2, delayMs: 0 }
-            );
+            console.log('[PASS] getMatchTimelineById:', timeline.metadata?.matchId);
+            const allMatchIds = await riot.getMatchlistByPuuidAll(puuid, { start: 0 }, undefined, { maxMatches: 2, delayMs: 0 });
             console.log('[PASS] getMatchlistByPuuidAll:', allMatchIds.length, 'match ids');
-
-            const withDetails = await riot.getMatchesWithDetailsByPuuid(
-                account.puuid,
-                { start: 0 },
-                undefined,
-                { maxMatches: 2, pageDelayMs: 0, detailDelayMs: 0 }
-            );
+            const withDetails = await riot.getMatchesWithDetailsByPuuid(puuid, { start: 0 }, undefined, { maxMatches: 2, pageDelayMs: 0, detailDelayMs: 0 });
             console.log('[PASS] getMatchesWithDetailsByPuuid:', withDetails.matches.length, 'matches');
-        } else {
+        }
+        else {
+            // Maintainer note (Timmsy): no-match accounts are valid, so keep this as a skip rather than a failure.
             console.log('[SKIP] Match-by-id/timeline/all/details checks: no matches returned');
         }
-    } else if (process.env.RIOT_API_KEY) {
+    }
+    else if (process.env.RIOT_API_KEY) {
         console.log('[SKIP] Riot endpoints: set TEST_RIOT_ID (and TEST_TAG_LINE if needed)');
-    } else {
+    }
+    else {
         console.log('[SKIP] Riot endpoints: set RIOT_API_KEY and TEST_RIOT_ID');
     }
-
     const champions = await dd.getChampions();
     console.log('[PASS] getChampions:', Object.keys(champions.data || {}).length, 'champions');
     console.log('[INFO] DataDragon version:', dd.version);
-
     const items = await dd.getItems();
     console.log('[PASS] getItems:', Object.keys(items.data || {}).length, 'items');
 }
-
 run().catch((error) => {
-    console.error('[FAIL]', error.message);
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('[FAIL]', message);
     process.exitCode = 1;
 });

package/dist/types.d.ts

@@ -0,0 +1,60 @@
+import type { AxiosInstance } from 'axios';
+export type RegionCode = 'BR1' | 'EUN1' | 'EUW1' | 'JP1' | 'KR' | 'LA1' | 'LA2' | 'NA1' | 'OC1' | 'TR1' | 'RU' | 'PH2' | 'SG2' | 'TH2' | 'TW2' | 'VN2';
+export interface RegionHosts {
+    platform: string;
+    shard: string;
+}
+export type RegionMap = Record<RegionCode, RegionHosts>;
+export interface MatchlistOptions {
+    startTime?: number;
+    endTime?: number;
+    queue?: number;
+    type?: string;
+    start?: number;
+    count?: number;
+}
+export interface MatchlistAllPacing {
+    delayMs?: number;
+    maxMatches?: number | null;
+}
+export interface MatchDetailsPacing {
+    pageDelayMs?: number;
+    detailDelayMs?: number;
+    maxMatches?: number | null;
+}
+export interface RankEntry extends Record<string, unknown> {
+    queueType?: string;
+    wins?: number;
+    losses?: number;
+}
+export interface RankEntryWithMetrics extends RankEntry {
+    winRate: number;
+}
+export interface RiotEndpointMethods {
+    getAccountByRiotId(riotId: string, tagLine?: string | null, region?: RegionCode): Promise<Record<string, unknown>>;
+    getSummonerByPuuid(puuid: string, region?: RegionCode): Promise<Record<string, unknown>>;
+    getRankEntriesByPuuid(puuid: string, region?: RegionCode): Promise<RankEntry[]>;
+    getRankByPuuid(puuid: string, region?: RegionCode): Promise<{
+        solo: RankEntryWithMetrics | null;
+        flex: RankEntryWithMetrics | null;
+        entries: RankEntry[];
+    }>;
+    getMatchlistByPuuid(puuid: string, options?: MatchlistOptions, region?: RegionCode): Promise<string[]>;
+    getMatchById(matchId: string, region?: RegionCode): Promise<Record<string, unknown>>;
+    getMatchTimelineById(matchId: string, region?: RegionCode): Promise<Record<string, unknown>>;
+    getMatchlistByPuuidAll(puuid: string, options?: MatchlistOptions, region?: RegionCode, pacing?: MatchlistAllPacing): Promise<string[]>;
+    getMatchesWithDetailsByPuuid(puuid: string, options?: MatchlistOptions, region?: RegionCode, pacing?: MatchDetailsPacing): Promise<{
+        matchIds: string[];
+        matches: Record<string, unknown>[];
+    }>;
+}
+export interface RiotEndpointsFactoryArgs {
+    client: AxiosInstance;
+    defaultRegion: RegionCode;
+    regionMap: RegionMap;
+    handleError: (error: unknown) => Error;
+}
+export interface DataDragonEndpointMethods {
+    getChampions(): Promise<Record<string, unknown>>;
+    getItems(): Promise<Record<string, unknown>>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,15 +1,34 @@
 {
   "name": "@timmsy/riftjs",
-  "version": "2.1.0",
-  "main": "index.js",
+  "version": "3.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
+    "build": "tsc -p tsconfig.json",
     "test": "npm run test:endpoints",
-    "test:endpoints": "node test-endpoints.js"
+    "test:endpoints": "npm run build && node dist/test-endpoints.js",
+    "prepack": "npm run build"
   },
   "dependencies": {
     "axios": "^1.7.7",
     "dotenv": "^16.4.5"
   },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.8.2"
+  },
   "keywords": [
     "riot-api",
     "league-of-legends",
@@ -20,6 +39,7 @@
     "game-data",
     "node-js",
     "javascript",
+    "typescript",
     "api-wrapper"
   ],
   "author": "James Timms",

package/.github/workflows/publish.yml

@@ -1,52 +0,0 @@
-name: Publish package
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Run tests
-        run: npm test
-
-      - name: Validate tag matches package version
-        run: |
-          TAG_VERSION="${GITHUB_REF_NAME#v}"
-          PKG_VERSION="$(node -p "require('./package.json').version")"
-          if [ "$TAG_VERSION" != "$PKG_VERSION" ]; then
-            echo "Tag version v$TAG_VERSION does not match package.json version $PKG_VERSION"
-            exit 1
-          fi
-
-      - name: Publish to npm
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Publish to GitHub Packages
-        run: |
-          echo "@timmsy:registry=https://npm.pkg.github.com" >> "$NPM_CONFIG_USERCONFIG"
-          echo "//npm.pkg.github.com/:_authToken=${NODE_AUTH_TOKEN}" >> "$NPM_CONFIG_USERCONFIG"
-          npm pkg set name="@timmsy1998/riftjs"
-          npm publish --registry=https://npm.pkg.github.com
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/endpoints/datadragon.js

@@ -1,40 +0,0 @@
-const axios = require('axios');
-
-module.exports = (baseURLOrResolver) => {
-    const resolveBaseURL = async () => {
-        if (typeof baseURLOrResolver === 'function') {
-            return baseURLOrResolver();
-        }
-        return baseURLOrResolver;
-    };
-
-    return {
-        /**
-         * Fetch champion metadata for the configured Data Dragon version/locale.
-         * @returns {Promise<object>} Champion data.
-         */
-        async getChampions() {
-            try {
-                const baseURL = await resolveBaseURL();
-                const response = await axios.get(`${baseURL}/champion.json`);
-                return response.data;
-            } catch (error) {
-                throw new Error(`DataDragon error: ${error.message}`);
-            }
-        },
-
-        /**
-         * Fetch item metadata for the configured Data Dragon version/locale.
-         * @returns {Promise<object>} Item data.
-         */
-        async getItems() {
-            try {
-                const baseURL = await resolveBaseURL();
-                const response = await axios.get(`${baseURL}/item.json`);
-                return response.data;
-            } catch (error) {
-                throw new Error(`DataDragon error: ${error.message}`);
-            }
-        },
-    };
-};

package/endpoints/riot.js

@@ -1,217 +0,0 @@
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const SOLO_QUEUE = 'RANKED_SOLO_5x5';
-const FLEX_QUEUE = 'RANKED_FLEX_SR';
-const withRankMetrics = (entry) => {
-    if (!entry) return null;
-    const wins = Number(entry.wins) || 0;
-    const losses = Number(entry.losses) || 0;
-    const gamesPlayed = wins + losses;
-    const winRate = gamesPlayed > 0 ? Number(((wins / gamesPlayed) * 100).toFixed(2)) : 0;
-    return { ...entry, winRate };
-};
-
-module.exports = (client, defaultRegion, regionMap) => ({
-    /**
-     * Fetch account data by Riot ID.
-     * @param {string} riotId - Riot ID (e.g., "Timmsy#BRUV" or "Timmsy", "BRUV").
-     * @param {string} [tagLine] - Optional tagLine if not included in riotId.
-     * @param {string} [region] - Region code used to resolve shard routing.
-     * @returns {Promise<object>} Account payload including `puuid`.
-     */
-    async getAccountByRiotId(riotId, tagLine = null, region = defaultRegion) {
-        let gameName, tag;
-        if (riotId.includes('#')) {
-            [gameName, tag] = riotId.split('#');
-        } else {
-            gameName = riotId;
-            tag = tagLine || '';
-        }
-        if (!tag) throw new Error('TagLine is required for getAccountByRiotId');
-        const shard = regionMap[region].shard;
-        try {
-            const response = await client.get(`/riot/account/v1/accounts/by-riot-id/${encodeURIComponent(gameName)}/${encodeURIComponent(tag)}`, {
-                baseURL: `https://${shard}`,
-            });
-            return response.data;
-        } catch (error) {
-            throw this._handleError(error);
-        }
-    },
-
-    /**
-     * Fetch Summoner-V4 data for a player's PUUID.
-     * @param {string} puuid - Encrypted PUUID.
-     * @param {string} [region] - Region code used to resolve platform routing.
-     * @returns {Promise<object>} Summoner payload.
-     */
-    async getSummonerByPuuid(puuid, region = defaultRegion) {
-        const platform = regionMap[region].platform;
-        try {
-            const response = await client.get(`/lol/summoner/v4/summoners/by-puuid/${encodeURIComponent(puuid)}`, {
-                baseURL: `https://${platform}`,
-            });
-            return response.data;
-        } catch (error) {
-            throw this._handleError(error);
-        }
-    },
-
-    /**
-     * Fetch all ranked entries for a player PUUID.
-     * @param {string} puuid - Player PUUID.
-     * @param {string} [region] - Region code used to resolve platform routing.
-     * @returns {Promise<object[]>} Ranked entries from League-V4.
-     */
-    async getRankEntriesByPuuid(puuid, region = defaultRegion) {
-        const platform = regionMap[region].platform;
-        try {
-            const response = await client.get(`/lol/league/v4/entries/by-puuid/${encodeURIComponent(puuid)}`, {
-                baseURL: `https://${platform}`,
-            });
-            return response.data;
-        } catch (error) {
-            throw this._handleError(error);
-        }
-    },
-
-    /**
-     * Fetch ranked info split into Solo and Flex queues.
-     * @param {string} puuid - Player PUUID.
-     * @param {string} [region] - Region code used to resolve platform routing.
-     * @returns {Promise<{solo: object|null, flex: object|null, entries: object[]}>} Queue-split rank payload.
-     */
-    async getRankByPuuid(puuid, region = defaultRegion) {
-        const entries = await this.getRankEntriesByPuuid(puuid, region);
-        const solo = withRankMetrics(entries.find((entry) => entry.queueType === SOLO_QUEUE) || null);
-        const flex = withRankMetrics(entries.find((entry) => entry.queueType === FLEX_QUEUE) || null);
-        return { solo, flex, entries };
-    },
-
-    /**
-     * Fetch match IDs for a PUUID from Match-V5.
-     * @param {string} puuid - Player PUUID.
-     * @param {object} [options] - Query params such as `start` and `count`.
-     * @param {string} [region] - Region code used to resolve shard routing.
-     * @returns {Promise<string[]>} Array of match IDs.
-     */
-    async getMatchlistByPuuid(puuid, options = {}, region = defaultRegion) {
-        const shard = regionMap[region].shard;
-        try {
-            const response = await client.get(`/lol/match/v5/matches/by-puuid/${encodeURIComponent(puuid)}/ids`, {
-                baseURL: `https://${shard}`,
-                params: options,
-            });
-            return response.data;
-        } catch (error) {
-            throw this._handleError(error);
-        }
-    },
-
-    /**
-     * Fetch full match details by match ID.
-     * @param {string} matchId - Match ID (e.g., "EUW1_1234567890").
-     * @param {string} [region] - Region code used to resolve shard routing.
-     * @returns {Promise<object>} Match payload.
-     */
-    async getMatchById(matchId, region = defaultRegion) {
-        const shard = regionMap[region].shard;
-        try {
-            const response = await client.get(`/lol/match/v5/matches/${matchId}`, {
-                baseURL: `https://${shard}`,
-            });
-            return response.data;
-        } catch (error) {
-            throw this._handleError(error);
-        }
-    },
-
-    /**
-     * Fetch match timeline data by match ID.
-     * @param {string} matchId - Match ID (e.g., "EUW1_1234567890").
-     * @param {string} [region] - Region code used to resolve shard routing.
-     * @returns {Promise<object>} Match timeline payload.
-     */
-    async getMatchTimelineById(matchId, region = defaultRegion) {
-        const shard = regionMap[region].shard;
-        try {
-            const response = await client.get(`/lol/match/v5/matches/${matchId}/timeline`, {
-                baseURL: `https://${shard}`,
-            });
-            return response.data;
-        } catch (error) {
-            throw this._handleError(error);
-        }
-    },
-
-    /**
-     * Fetch all match IDs for a PUUID using Riot's max page size (100).
-     * @param {string} puuid - Player PUUID.
-     * @param {object} [options] - Riot filters: startTime, endTime, queue, type, start.
-     * @param {string} [region] - Region code used to resolve shard routing.
-     * @param {object} [pacing] - Pacing controls.
-     * @param {number} [pacing.delayMs=1250] - Delay between page requests.
-     * @param {number|null} [pacing.maxMatches=null] - Optional cap on total IDs returned.
-     * @returns {Promise<string[]>} All matched IDs.
-     */
-    async getMatchlistByPuuidAll(puuid, options = {}, region = defaultRegion, pacing = {}) {
-        const baseStart = Number.isInteger(options.start) ? options.start : 0;
-        const pageDelayMs = Number.isInteger(pacing.delayMs) ? pacing.delayMs : 1250;
-        const maxMatches = Number.isInteger(pacing.maxMatches) && pacing.maxMatches >= 0 ? pacing.maxMatches : null;
-        const filters = {
-            startTime: options.startTime,
-            endTime: options.endTime,
-            queue: options.queue,
-            type: options.type,
-        };
-
-        let start = baseStart;
-        const allMatchIds = [];
-
-        while (true) {
-            const remaining = maxMatches === null ? 100 : Math.min(100, maxMatches - allMatchIds.length);
-            if (remaining <= 0) break;
-
-            const page = await this.getMatchlistByPuuid(puuid, { ...filters, start, count: remaining }, region);
-            allMatchIds.push(...page);
-
-            if (page.length < remaining) break;
-            start += page.length;
-            if (pageDelayMs > 0) await sleep(pageDelayMs);
-        }
-
-        return allMatchIds;
-    },
-
-    /**
-     * Fetch match IDs and full match payloads for each ID.
-     * @param {string} puuid - Player PUUID.
-     * @param {object} [options] - Riot filters: startTime, endTime, queue, type, start.
-     * @param {string} [region] - Region code used to resolve shard routing.
-     * @param {object} [pacing] - Pacing controls.
-     * @param {number} [pacing.pageDelayMs=1250] - Delay between matchlist page requests.
-     * @param {number} [pacing.detailDelayMs=1250] - Delay between match detail requests.
-     * @param {number|null} [pacing.maxMatches=null] - Optional cap on total matches fetched.
-     * @returns {Promise<{matchIds: string[], matches: object[]}>} IDs and full match payloads.
-     */
-    async getMatchesWithDetailsByPuuid(puuid, options = {}, region = defaultRegion, pacing = {}) {
-        const pageDelayMs = Number.isInteger(pacing.pageDelayMs) ? pacing.pageDelayMs : 1250;
-        const detailDelayMs = Number.isInteger(pacing.detailDelayMs) ? pacing.detailDelayMs : 1250;
-        const maxMatches = Number.isInteger(pacing.maxMatches) && pacing.maxMatches >= 0 ? pacing.maxMatches : null;
-        const matchIds = await this.getMatchlistByPuuidAll(
-            puuid,
-            options,
-            region,
-            { delayMs: pageDelayMs, maxMatches }
-        );
-        const matches = [];
-
-        for (let i = 0; i < matchIds.length; i += 1) {
-            matches.push(await this.getMatchById(matchIds[i], region));
-            if (detailDelayMs > 0 && i < matchIds.length - 1) {
-                await sleep(detailDelayMs);
-            }
-        }
-
-        return { matchIds, matches };
-    },
-});