clashofclans.js 1.5.4 → 2.0.0-dev.2c5b083

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+## 2.0.0 (2021-11-26)
+
+This new version is a complete TypeScript rewrite to convert everything from plain (literal JSON) objects to class (constructor) objects and support a lot more features.
+
+### Features
+
+-   API Date Parser and Request Retries ([#26](https://github.com/clashperk/clashofclans.js/issues/26)) ([94585f3](https://github.com/clashperk/clashofclans.js/commit/94585f3a84a7175b2d07872f9eb9e42372b95e12))
+-   EventManager and Custom Events ([#37](https://github.com/clashperk/clashofclans.js/issues/37)) ([5027ae6](https://github.com/clashperk/clashofclans.js/commit/5027ae663a8e07175e17384c7e5706f4a1a7afb4))
+-   Email Password Login ([#31](https://github.com/clashperk/clashofclans.js/issues/31)) ([4153cd3](https://github.com/clashperk/clashofclans.js/commit/4153cd37ea0e1c71550b9e892105b84d5a407e23))
+-   QueueThrottler and BatchThrottler ([#34](https://github.com/clashperk/clashofclans.js/issues/34)) ([3a8f051](https://github.com/clashperk/clashofclans.js/commit/3a8f051552e93b98f89bc7d524acdecddf242718))
+-   Override Request Options ([#36](https://github.com/clashperk/clashofclans.js/issues/36)) ([42d7fdd](https://github.com/clashperk/clashofclans.js/commit/42d7fdd36262cc46f23b731f8cffb9daea19d3b0))
+-   Internal Caching Options ([#53](https://github.com/clashperk/clashofclans.js/issues/53)) ([984451d](https://github.com/clashperk/clashofclans.js/commit/30ea3240c11866008d0dae514468c0fdbb34ffd0))
+-   Raw Data for Player Units ([#65](https://github.com/clashperk/clashofclans.js/pull/65)) ([aa1696](https://github.com/clashperk/clashofclans.js/commit/aa1696243d96d4fed0250b4282c60522a6482343))

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2020 - 2021 ClashPerk
+Copyright (c) 2020 - 2021 csuvajit
+Copyright (c) 2020 - 2021 TheLearneer
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,136 +4,65 @@
 
 ### JavaScript library for interacting with the Clash of Clans API
 
-[![ESLint](https://github.com/clashperk/clashofclans.js/actions/workflows/node.js.yml/badge.svg)](https://github.com/clashperk/clashofclans.js/actions/workflows/node.js.yml)
-[![Docs](https://github.com/clashperk/clashofclans.js/actions/workflows/docs.yml/badge.svg)](https://github.com/clashperk/clashofclans.js/actions/workflows/docs.yml)
+[![ESLint](https://github.com/clashperk/clashofclans.js/actions/workflows/eslint.yml/badge.svg)](https://github.com/clashperk/clashofclans.js/actions/workflows/node.js.yml)
 [![Logo](https://img.shields.io/npm/v/clashofclans.js.svg?maxAge=3600)](https://www.npmjs.com/package/clashofclans.js)
 
 </div>
 
 ### Installation
-- **`npm i clashofclans.js`**
-- **Node.js v14.0.0 or newer is required.**
+
+-   **`npm i clashofclans.js`**
+-   **Node.js v14 or newer is required.**
 
 ### Links
 
-- [Documentation](https://clashofclans.js.org/api/)
-- [Clash of Clans Developer Website](https://developer.clashofclans.com/)
-- [Clash of Clans API Community Discord](https://discord.gg/Eaja7gJ)
+-   [Documentation](https://clashofclans.js.org/docs/)
+-   [Clash of Clans Developer Website](https://developer.clashofclans.com/)
+-   [Clash of Clans API Community Discord](https://discord.gg/Eaja7gJ)
 
-### Example
+### Examples
 
 ```js
 const { Client } = require('clashofclans.js');
-const client = new Client({ keys: ['API_KEY'] });
-
-(async function() {
-	const data = await client.locations('#8QU8J9LP', { limit: 1 });
-	console.log(data);
-})();
-```
-
-### Response
-
-```json
-{
-    "items": [
-        {
-            "id": 32000000,
-            "name": "Europe",
-            "isCountry": false
-        }
-    ],
-    "paging": {},
-    "statusCode": 200,
-    "ok": true,
-    "maxAge": 600000
-}
-```
-
-### What is **`maxAge`**?
-
-The `maxAge` ([Cache-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control)) is the maximum amount of time in milliseconds (converted) which shows how long until a fresh data is available.
-
-### Validation
+const client = new Client();
 
-It's recommended to see if a data is available before performing operations or reading data from it. 
-You can check this with `data.ok` property.
+(async function () {
+    await client.login({ email: 'developer@email.com', password: '***' });
 
-```js
-(async function() {
-	const data = await client.clan('#WRONG_TAG');
-	console.log(data);
-	if (!data.ok) return; // Invalid Tag
+    const clan = await client.getClan('#2PP');
+    console.log(`${clan.name} (${clan.tag})`);
 })();
 ```
 
-```json
-{
-    "reason": "notFound",
-    "statusCode": 404,
-    "ok": false,
-    "maxAge": 600000
-}
-```
-
-### Status Codes
-- **200:** Successful Response.
-- **400:** Client provided incorrect parameters for the request.
-- **403:** Access denied, either because of missing/incorrect credentials or used API token does not grant access to the requested resource.
-- **404:** Resource was not found.
-- **429:** Request was throttled, because amount of requests was above the threshold defined for the used API token.
-- **500:** Unknown error happened when handling the request.
-- **503:** Service is temporarily unavailable because of maintenance.
-- **504:** Request Timeout.
-
-## Methods
-
-| Methods                                                               | Description                       |
-| --------------------------------------------------------------------- | --------------------------------- |
-| [init(options)](https://clashofclans.js.org/api#Client#init)                                         | Initialize Extension class and create keys |
-| [parseTag(tag)](https://clashofclans.js.org/api#Client#parseTag)                                     | Parse a clan or player Tag |
-| [clans([options])](https://clashofclans.js.org/api#Client#clans)                                     | Search clans |
-| [clan(clanTag)](https://clashofclans.js.org/api#Client#clan)                                         | Get clan information |
-| [clanMembers(clanTag, [options])](https://clashofclans.js.org/api#Client#clanMembers)                | List clan members |
-| [detailedClanMembers(members)](https://clashofclans.js.org/api#Client#detailedClanMembers)           | Detailed clan members |
-| [clanWarLog(clanTag, [options])](https://clashofclans.js.org/api#Client#clanWarLog)                  | Retrieve clan's clan war log |
-| [currentClanWar(clanTag, [options])](https://clashofclans.js.org/api#Client#currentClanWar)          | Information about clan's current clan war |
-| [clanWarLeague(clanTag)](https://clashofclans.js.org/api#Client#clanWarLeague)                       | Information about clan's current clan war league group |
-| [clanWarLeagueWar(warTag)](https://clashofclans.js.org/api#Client#clanWarLeagueWar)                  | Information about individual clan war league war |
-| [player(playerTag)](https://clashofclans.js.org/api#Client#player)                                   | Get player information |
-| [verifyPlayerToken(playerTag, token)](https://clashofclans.js.org/api#Client#verifyPlayerToken)      | Verify player API token |
-| [leagues([options])](https://clashofclans.js.org/api#Client#leagues)                                 | List Leagues |
-| [league(leagueId)](https://clashofclans.js.org/api#Client#league)                                    | Get league information |
-| [leagueSeason(leagueId, [options])](https://clashofclans.js.org/api#Client#leagueSeason)             | Get league seasons |
-| [leagueRanking(leagueId, seasonId, [options])](https://clashofclans.js.org/api#Client#leagueRanking) | Get league season rankings |
-| [warLeagues([options])](https://clashofclans.js.org/api#Client#warLeagues)                           | List war leagues |
-| [warLeague(leagueId)](https://clashofclans.js.org/api#Client#warLeague)                              | Get war league information |
-| [locations([options])](https://clashofclans.js.org/api#Client#locations)                             | List locations |
-| [location(locationId)](https://clashofclans.js.org/api#Client#location)                              | Get information about specific location |
-| [clanRanks(locationId, [options])](https://clashofclans.js.org/api#Client#clanRanks)                 | Get clan rankings for a specific location |
-| [playerRanks(locationId, [options])](https://clashofclans.js.org/api#Client#playerRanks)             | Get player rankings for a specific location |
-| [versusClanRanks(locationId, [options])](https://clashofclans.js.org/api#Client#versusClanRanks)     | Get clan versus rankings for a specific location |
-| [versusPlayerRanks(locationId, [options])](https://clashofclans.js.org/api#Client#versusPlayerRanks) | Get player versus rankings for a specific location |
-| [clanLabels([options])](https://clashofclans.js.org/api#Client#clanLabels)                           | List clan labels |
-| [playerLabels([options])](https://clashofclans.js.org/api#Client#playerLabels)                       | List player labels |
-| [goldPassSeason()](https://clashofclans.js.org/api#Client#goldPassSeason)                            | Get information about the current gold pass season |
-
-### Create API Token
-
-This method is for creating API keys for the external IP the code is running on. Therefore no static IP is required and always ready to be deployed on Serverless platform like Heroku.
+### Custom Event
 
 ```js
-const { Client } = require('clashofclans.js');
-const client = new Client();
-
-(async () => {
-	await client.init({ email: '', password: '' });
-	// you would have to run the `init` method just for once.
-    
-	const data = await client.clan('#2PP');
-	console.log(data);
+const { Client, BatchThrottler } = require('clashofclans.js');
+const client = new Client({
+    cache: true,
+    retryLimit: 1,
+    restRequestTimeout: 5000,
+    throttler: new BatchThrottler(20)
+});
+
+client.events.addClans(['#8QU8J9LP', '#8P2QG08P']);
+client.events.setClanEvent({
+    name: 'clanDescriptionChange',
+    filter: (oldClan, newClan) => {
+        return oldClan.description !== newClan.description;
+    }
+});
+
+client.on('clanDescriptionChange', (oldClan, newClan) => {
+    console.log(oldClan.description, newClan.description);
+});
+
+(async function () {
+    await client.login({ email: 'developer@email.com', password: '***' });
+    await client.events.init();
 })();
 ```
 
 ### Disclaimer
-> This content is not affiliated with, endorsed, sponsored, or specifically approved by Supercell and Supercell is not responsible for it. For more information see [Supercell’s Fan Content Policy](https://supercell.com/en/fan-content-policy/).
+
+> This content is not affiliated with, endorsed, sponsored, or specifically approved by Supercell and Supercell is not responsible for it. For more information see [Supercell's Fan Content Policy](https://supercell.com/en/fan-content-policy/).

package/dist/client/Client.d.ts

@@ -0,0 +1,177 @@
+/// <reference types="node" />
+import { ClanSearchOptions, SearchOptions, ClientOptions, InitOptions, OverrideOptions } from '../rest/RequestHandler';
+import { EVENTS, CWL_ROUNDS } from '../util/Constants';
+import { RESTManager } from '../rest/RESTManager';
+import { EventManager } from './EventManager';
+import { EventEmitter } from 'events';
+import { Util } from '../util/Util';
+import { Clan, ClanMember, ClanWar, ClanWarLog, League, Location, Player, WarLeague, RankedClan, RankedPlayer, Label, GoldPassSeason, ClanWarLeagueGroup } from '../struct';
+/**
+ * Represents Clash of Clans API Client.
+ * ```js
+ * const { Client } = require('clashofclans.js');
+ * const client = new Client({ keys: ['***'] });
+ * ```
+ */
+export declare class Client extends EventEmitter {
+    /** Event Manager for the client. */
+    readonly events: EventManager;
+    /** REST Handler of the client. */
+    readonly rest: RESTManager;
+    constructor(options?: ClientOptions);
+    /** Contains various general-purpose utility methods. */
+    get util(): typeof Util;
+    /** Whether the API is in maintenance break. */
+    get inMaintenance(): boolean;
+    /**
+     * Initialize the client to create keys.
+     * @example
+     * ```
+     * const client = new Client();
+     * client.login({ email: 'developer@email.com', password: '***' });
+     * ```
+     */
+    login(options: InitOptions): Promise<string[]>;
+    /** Set Clash of Clans API keys. */
+    setKeys(keys: string[]): this;
+    /** Search all clans by name and/or filtering the results using various criteria. */
+    getClans(options: ClanSearchOptions): Promise<Clan[]>;
+    /** Get information about a clan. */
+    getClan(clanTag: string, options?: OverrideOptions): Promise<Clan>;
+    /** Get list of clan members. */
+    getClanMembers(clanTag: string, options?: SearchOptions): Promise<ClanMember[]>;
+    /** Get clan war log. */
+    getClanWarLog(clanTag: string, options?: SearchOptions): Promise<ClanWarLog[]>;
+    /** Get info about currently running war (normal or friendly) in the clan. */
+    getClanWar(clanTag: string, options?: OverrideOptions): Promise<ClanWar>;
+    /**
+     * Get info about currently running war in the clan.
+     * @example
+     * ```ts
+     * await client.getCurrentWar('#8QU8J9LP');
+     * ```
+     * @example
+     * ```ts
+     * await client.getCurrentWar({ clanTag: '#8QU8J9LP', round: 'PREVIOUS_ROUND' });
+     * ```
+     */
+    getCurrentWar(clanTag: string | {
+        clanTag: string;
+        round?: keyof typeof CWL_ROUNDS;
+    }, options?: OverrideOptions): Promise<ClanWar | null>;
+    /**
+     * Get info about currently running CWL round.
+     * @example
+     * ```ts
+     * await client.getLeagueWar('#8QU8J9LP');
+     * ```
+     * @example
+     * ```ts
+     * await client.getLeagueWar({ clanTag: '#8QU8J9LP', round: 'PREVIOUS_ROUND' });
+     * ```
+     */
+    getLeagueWar(clanTag: string | {
+        clanTag: string;
+        round?: keyof typeof CWL_ROUNDS;
+    }, options?: OverrideOptions): Promise<ClanWar | null>;
+    private _getCurrentLeagueWars;
+    private _getClanWars;
+    /** Get information about clan war league. */
+    getClanWarLeagueGroup(clanTag: string, options?: OverrideOptions): Promise<ClanWarLeagueGroup>;
+    /** Get info about a CWL round by WarTag. */
+    getClanWarLeagueRound(warTag: string | {
+        warTag: string;
+        clanTag?: string;
+    }, options?: OverrideOptions): Promise<ClanWar>;
+    /** Get information about a player by tag. */
+    getPlayer(playerTag: string, options?: OverrideOptions): Promise<Player>;
+    /** Verify Player API token that can be found from the Game settings. */
+    verifyPlayerToken(playerTag: string, token: string, options?: OverrideOptions): Promise<boolean>;
+    /** Get list of Leagues. */
+    getLeagues(options?: SearchOptions): Promise<League[]>;
+    /** Get Legend League season Ids. */
+    getLeagueSeasons(options?: SearchOptions): Promise<string[]>;
+    /** Get Legend League season rankings by season Id. */
+    getSeasonRankings(seasonId: string, options?: SearchOptions): Promise<RankedPlayer[]>;
+    /** Get list of Clan War Leagues. */
+    getWarLeagues(options?: SearchOptions): Promise<WarLeague[]>;
+    /** Get list of Locations. */
+    getLocations(options?: SearchOptions): Promise<Location[]>;
+    /** Get clan rankings for a specific location. */
+    getClanRanks(locationId: number | 'global', options?: SearchOptions): Promise<RankedClan[]>;
+    /** Get player rankings for a specific location. */
+    getPlayerRanks(locationId: number | 'global', options?: SearchOptions): Promise<RankedPlayer[]>;
+    /** Get clan versus rankings for a specific location. */
+    getVersusClanRanks(locationId: number | 'global', options?: SearchOptions): Promise<RankedClan[]>;
+    /** Get player versus rankings for a specific location. */
+    getVersusPlayerRanks(locationId: number | 'global', options?: SearchOptions): Promise<RankedPlayer[]>;
+    /** Get list of clan labels. */
+    getClanLabels(options?: SearchOptions): Promise<Label[]>;
+    /** Get list of player labels. */
+    getPlayerLabels(options?: SearchOptions): Promise<Label[]>;
+    /** Get info about gold pass season. */
+    getGoldPassSeason(options?: OverrideOptions): Promise<GoldPassSeason>;
+    /**
+     * Emits when a new season starts.
+     *
+     * **Parameters**
+     *
+     * | Name |   Type   | Description           |
+     * | :--: | :------: | :-------------------: |
+     * | `id` | `string` | Id of the new season. |
+     * @public
+     * @event
+     */
+    private static newSeasonStart;
+    /**
+     * Emits when maintenance break starts in the API.
+     * @public
+     * @event
+     */
+    private static maintenanceStart;
+    /**
+     * Emits when maintenance break ends in the API.
+     *
+     * **Parameters**
+     *
+     * |    Name    |   Type   |                    Description                     |
+     * | :--------: | :------: | :------------------------------------------------: |
+     * | `duration` | `number` | Duration of the maintenance break in milliseconds. |
+     * @public
+     * @event
+     */
+    private static maintenanceEnd;
+    /** @internal */
+    on<K extends keyof ClientEvents>(event: K, listeners: (...args: ClientEvents[K]) => void): this;
+    /** @internal */
+    on<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientEvents>, listeners: (...args: CustomEvents[S]) => void): this;
+    /** @internal */ on<S extends string | symbol>(event: Exclude<S, keyof ClientEvents>, listeners: (...args: any[]) => void): this;
+    /** @internal */
+    once<K extends keyof ClientEvents>(event: K, listeners: (...args: ClientEvents[K]) => void): this;
+    /** @internal */
+    once<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientEvents>, listeners: (...args: CustomEvents[S]) => void): this;
+    /** @internal */ once<S extends string | symbol>(event: Exclude<S, keyof ClientEvents>, listeners: (...args: any[]) => void): this;
+    /** @internal */
+    emit<K extends keyof ClientEvents>(event: K, ...args: ClientEvents[K]): boolean;
+    /** @internal */
+    emit<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientEvents>, ...args: CustomEvents[S]): this;
+    /** @internal */ emit<S extends string | symbol>(event: Exclude<S, keyof ClientEvents>, ...args: any[]): boolean;
+}
+interface ClientEvents {
+    [EVENTS.NEW_SEASON_START]: [id: string];
+    [EVENTS.MAINTENANCE_START]: [];
+    [EVENTS.MAINTENANCE_END]: [duration: number];
+    [EVENTS.CLAN_LOOP_START]: [];
+    [EVENTS.CLAN_LOOP_END]: [];
+    [EVENTS.PLAYER_LOOP_START]: [];
+    [EVENTS.PLAYER_LOOP_END]: [];
+    [EVENTS.WAR_LOOP_START]: [];
+    [EVENTS.WAR_LOOP_END]: [];
+    [EVENTS.ERROR]: [error: unknown];
+}
+interface CustomEvents {
+    [key: `clan${string}`]: [oldClan: Clan, newClan: Clan];
+    [key: `war${string}`]: [oldWar: ClanWar, newWar: ClanWar];
+    [key: `player${string}`]: [oldPlayer: Player, newPlayer: Player];
+}
+export {};

package/dist/client/Client.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const Constants_1 = require("../util/Constants");
+const HTTPError_1 = require("../rest/HTTPError");
+const RESTManager_1 = require("../rest/RESTManager");
+const EventManager_1 = require("./EventManager");
+const events_1 = require("events");
+const Util_1 = require("../util/Util");
+const struct_1 = require("../struct");
+/**
+ * Represents Clash of Clans API Client.
+ * ```js
+ * const { Client } = require('clashofclans.js');
+ * const client = new Client({ keys: ['***'] });
+ * ```
+ */
+class Client extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.rest = new RESTManager_1.RESTManager(options);
+        this.events = new EventManager_1.EventManager(this);
+    }
+    /** Contains various general-purpose utility methods. */
+    get util() {
+        return Util_1.Util;
+    }
+    /** Whether the API is in maintenance break. */
+    get inMaintenance() {
+        // @ts-expect-error
+        return this.events._inMaintenance;
+    }
+    /**
+     * Initialize the client to create keys.
+     * @example
+     * ```
+     * const client = new Client();
+     * client.login({ email: 'developer@email.com', password: '***' });
+     * ```
+     */
+    login(options) {
+        return this.rest.handler.init(options);
+    }
+    /** Set Clash of Clans API keys. */
+    setKeys(keys) {
+        this.rest.handler.setKeys(keys);
+        return this;
+    }
+    /** Search all clans by name and/or filtering the results using various criteria. */
+    async getClans(options) {
+        const { data } = await this.rest.getClans(options);
+        // @ts-expect-error
+        return data.items.map((clan) => new struct_1.Clan(this, clan));
+    }
+    /** Get information about a clan. */
+    async getClan(clanTag, options) {
+        const { data } = await this.rest.getClan(clanTag, options);
+        return new struct_1.Clan(this, data);
+    }
+    /** Get list of clan members. */
+    async getClanMembers(clanTag, options) {
+        const { data } = await this.rest.getClanMembers(clanTag, options);
+        return data.items.map((entry) => new struct_1.ClanMember(this, entry));
+    }
+    /** Get clan war log. */
+    async getClanWarLog(clanTag, options) {
+        const { data } = await this.rest.getClanWarLog(clanTag, options);
+        return data.items.map((entry) => new struct_1.ClanWarLog(this, entry));
+    }
+    /** Get info about currently running war (normal or friendly) in the clan. */
+    async getClanWar(clanTag, options) {
+        const { data, maxAge, path, status } = await this.rest.getCurrentWar(clanTag, options);
+        if (data.state === 'notInWar') {
+            throw new HTTPError_1.HTTPError(HTTPError_1.NotInWarError, status, path, maxAge);
+        }
+        return new struct_1.ClanWar(this, data, { clanTag, maxAge });
+    }
+    /**
+     * Get info about currently running war in the clan.
+     * @example
+     * ```ts
+     * await client.getCurrentWar('#8QU8J9LP');
+     * ```
+     * @example
+     * ```ts
+     * await client.getCurrentWar({ clanTag: '#8QU8J9LP', round: 'PREVIOUS_ROUND' });
+     * ```
+     */
+    async getCurrentWar(clanTag, options) {
+        const args = typeof clanTag === 'string' ? { clanTag } : { clanTag: clanTag.clanTag, round: clanTag.round };
+        try {
+            return await this.getClanWar(args.clanTag, options);
+        }
+        catch (e) {
+            if (e instanceof HTTPError_1.HTTPError && [200, 403].includes(e.status)) {
+                return this.getLeagueWar({ clanTag: args.clanTag, round: args.round }, options);
+            }
+            throw e;
+        }
+    }
+    /**
+     * Get info about currently running CWL round.
+     * @example
+     * ```ts
+     * await client.getLeagueWar('#8QU8J9LP');
+     * ```
+     * @example
+     * ```ts
+     * await client.getLeagueWar({ clanTag: '#8QU8J9LP', round: 'PREVIOUS_ROUND' });
+     * ```
+     */
+    async getLeagueWar(clanTag, options) {
+        const args = typeof clanTag === 'string' ? { clanTag } : { clanTag: clanTag.clanTag, round: clanTag.round };
+        const state = (args.round && Constants_1.CWL_ROUNDS[args.round]) ?? 'inWar'; // eslint-disable-line
+        const data = await this.getClanWarLeagueGroup(args.clanTag, options);
+        const rounds = data.rounds.filter((round) => !round.warTags.includes('#0'));
+        if (!rounds.length)
+            return null;
+        const num = state === 'preparation' ? -1 : state === 'warEnded' ? -3 : -2;
+        const warTags = rounds
+            .slice(num)
+            .map((round) => round.warTags)
+            .flat()
+            .reverse();
+        const wars = await this.util.allSettled(warTags.map((warTag) => this.getClanWarLeagueRound({ warTag, clanTag: args.clanTag }, { ...options, ignoreRateLimit: true })));
+        if (args.round && args.round in Constants_1.CWL_ROUNDS) {
+            return wars.find((war) => war.state === state) ?? null;
+        }
+        return wars.find((war) => war.state === state) ?? wars.at(0) ?? null;
+    }
+    async _getCurrentLeagueWars(clanTag, options) {
+        const data = await this.getClanWarLeagueGroup(clanTag, options);
+        // @ts-expect-error
+        return data._getCurrentWars(clanTag, options);
+    }
+    async _getClanWars(clanTag, options) {
+        const date = new Date().getUTCDate();
+        if (!(date >= 1 && date <= 10)) {
+            return [await this.getClanWar(clanTag, options)];
+        }
+        try {
+            return this._getCurrentLeagueWars(clanTag, options);
+        }
+        catch (e) {
+            if (e instanceof HTTPError_1.HTTPError && [404].includes(e.status)) {
+                return [await this.getClanWar(clanTag, options)];
+            }
+            throw e;
+        }
+    }
+    /** Get information about clan war league. */
+    async getClanWarLeagueGroup(clanTag, options) {
+        const { data } = await this.rest.getClanWarLeagueGroup(clanTag, options);
+        return new struct_1.ClanWarLeagueGroup(this, data);
+    }
+    /** Get info about a CWL round by WarTag. */
+    async getClanWarLeagueRound(warTag, options) {
+        const args = typeof warTag === 'string' ? { warTag } : { warTag: warTag.warTag, clanTag: warTag.clanTag };
+        const { data, maxAge, status, path } = await this.rest.getClanWarLeagueRound(args.warTag, options);
+        if (data.state === 'notInWar') {
+            throw new HTTPError_1.HTTPError(HTTPError_1.NotInWarError, status, path, maxAge);
+        }
+        return new struct_1.ClanWar(this, data, { warTag: args.warTag, clanTag: args.clanTag, maxAge });
+    }
+    /** Get information about a player by tag. */
+    async getPlayer(playerTag, options) {
+        const { data } = await this.rest.getPlayer(playerTag, options);
+        return new struct_1.Player(this, data);
+    }
+    /** Verify Player API token that can be found from the Game settings. */
+    async verifyPlayerToken(playerTag, token, options) {
+        const { data } = await this.rest.verifyPlayerToken(playerTag, token, options);
+        return data.status === 'ok';
+    }
+    /** Get list of Leagues. */
+    async getLeagues(options) {
+        const { data } = await this.rest.getLeagues(options);
+        return data.items.map((entry) => new struct_1.League(entry));
+    }
+    /** Get Legend League season Ids. */
+    async getLeagueSeasons(options) {
+        const { data } = await this.rest.getLeagueSeasons(Constants_1.LEGEND_LEAGUE_ID, options);
+        return data.items.map((league) => league.id);
+    }
+    /** Get Legend League season rankings by season Id. */
+    async getSeasonRankings(seasonId, options) {
+        const { data } = await this.rest.getSeasonRankings(Constants_1.LEGEND_LEAGUE_ID, seasonId, options);
+        // @ts-expect-error
+        return data.items.map((entry) => new struct_1.RankedPlayer(entry));
+    }
+    /** Get list of Clan War Leagues. */
+    async getWarLeagues(options) {
+        const { data } = await this.rest.getWarLeagues(options);
+        return data.items.map((entry) => new struct_1.WarLeague(entry));
+    }
+    /** Get list of Locations. */
+    async getLocations(options) {
+        const { data } = await this.rest.getLocations(options);
+        return data.items.map((entry) => new struct_1.Location(entry));
+    }
+    /** Get clan rankings for a specific location. */
+    async getClanRanks(locationId, options) {
+        const { data } = await this.rest.getClanRanks(locationId, options);
+        return data.items.map((entry) => new struct_1.RankedClan(entry));
+    }
+    /** Get player rankings for a specific location. */
+    async getPlayerRanks(locationId, options) {
+        const { data } = await this.rest.getPlayerRanks(locationId, options);
+        return data.items.map((entry) => new struct_1.RankedPlayer(this, entry));
+    }
+    /** Get clan versus rankings for a specific location. */
+    async getVersusClanRanks(locationId, options) {
+        const { data } = await this.rest.getVersusClanRanks(locationId, options);
+        return data.items.map((entry) => new struct_1.RankedClan(entry));
+    }
+    /** Get player versus rankings for a specific location. */
+    async getVersusPlayerRanks(locationId, options) {
+        const { data } = await this.rest.getVersusPlayerRanks(locationId, options);
+        return data.items.map((entry) => new struct_1.RankedPlayer(this, entry));
+    }
+    /** Get list of clan labels. */
+    async getClanLabels(options) {
+        const { data } = await this.rest.getClanLabels(options);
+        return data.items.map((entry) => new struct_1.Label(entry));
+    }
+    /** Get list of player labels. */
+    async getPlayerLabels(options) {
+        const { data } = await this.rest.getPlayerLabels(options);
+        return data.items.map((entry) => new struct_1.Label(entry));
+    }
+    /** Get info about gold pass season. */
+    async getGoldPassSeason(options) {
+        const { data } = await this.rest.getGoldPassSeason(options);
+        return new struct_1.GoldPassSeason(data);
+    }
+}
+exports.Client = Client;