clashofclans.js 2.0.0-dev.7f4d9f8 → 2.0.0-dev.86dfaef

package/README.md

@@ -45,8 +45,7 @@ const client = new Client({
 });
 
 client.events.addClans(['#8P2QG08P']);
-client.events.setEvent({
-    type: 'CLAN',
+client.events.setClanEvent({
     name: 'clanDescriptionChange',
     filter: (oldClan, newClan) => {
         return oldClan.description !== newClan.description;

package/dist/client/Client.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { ClanSearchOptions, SearchOptions, ClientOptions, InitOptions, OverrideOptions } from '../rest/RequestHandler';
-import { EVENTS } from '../util/Constants';
+import { EVENTS, CWL_ROUNDS } from '../util/Constants';
 import { RESTManager } from '../rest/RESTManager';
 import { EventManager } from './EventManager';
 import { EventEmitter } from 'events';
@@ -40,12 +40,38 @@ export declare class Client extends EventEmitter {
     getClanMembers(clanTag: string, options?: SearchOptions): Promise<ClanMember[]>;
     /** Get clan war log. */
     getClanWarLog(clanTag: string, options?: SearchOptions): Promise<ClanWarLog[]>;
-    /** Get info about currently running war (regular or friendly) in the clan. */
-    getClanWar(clanTag: string, options?: OverrideOptions): Promise<ClanWar | null>;
-    /** Get info about currently running war in the clan. */
-    getCurrentWar(clanTag: string, options?: OverrideOptions): Promise<ClanWar | null>;
-    /** Get info about currently running CWL round. */
-    getLeagueWar(clanTag: string, warState?: keyof typeof CWLRound): Promise<ClanWar | null>;
+    /** 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. */
@@ -54,7 +80,7 @@ export declare class Client extends EventEmitter {
     getClanWarLeagueRound(warTag: string | {
         warTag: string;
         clanTag?: string;
-    }, options?: OverrideOptions): Promise<ClanWar | null>;
+    }, 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. */
@@ -88,8 +114,8 @@ export declare class Client extends EventEmitter {
      *
      * **Parameters**
      *
-     * | Name | Type | Description |
-     * | :--: | :--: | :---------: |
+     * | Name |   Type   | Description           |
+     * | :--: | :------: | :-------------------: |
      * | `id` | `string` | Id of the new season. |
      * @public
      * @event
@@ -106,8 +132,8 @@ export declare class Client extends EventEmitter {
      *
      * **Parameters**
      *
-     * | Name | Type | Description |
-     * | :--: | :--: | :---------: |
+     * |    Name    |   Type   |                    Description                     |
+     * | :--------: | :------: | :------------------------------------------------: |
      * | `duration` | `number` | Duration of the maintenance break in milliseconds. |
      * @public
      * @event
@@ -135,13 +161,3 @@ export interface ClientEvents {
     [EVENTS.WAR_LOOP_END]: [];
     [EVENTS.ERROR]: [error: unknown];
 }
-export interface EventTypes {
-    CLAN: [oldClan: Clan, newClan: Clan];
-    PLAYER: [oldPlayer: Player, newPlayer: Player];
-    CLAN_WAR: [oldWar: ClanWar, newWar: ClanWar];
-}
-export declare const CWLRound: {
-    readonly PREVIOUS_WAR: "warEnded";
-    readonly CURRENT_WAR: "inWar";
-    readonly NEXT_WAR: "preparation";
-};

package/dist/client/Client.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CWLRound = exports.Client = void 0;
+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 HTTPError_1 = require("../rest/HTTPError");
 const events_1 = require("events");
 const Util_1 = require("../util/Util");
 const struct_1 = require("../struct");
@@ -62,30 +62,52 @@ class Client extends events_1.EventEmitter {
         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 (regular or friendly) in the clan. */
+    /** Get info about currently running war (normal or friendly) in the clan. */
     async getClanWar(clanTag, options) {
-        const { data, maxAge } = await this.rest.getCurrentWar(clanTag, options);
-        if (data.state === 'notInWar')
-            return null;
+        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. */
+    /**
+     * 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 {
-            const data = await this.getClanWar(clanTag, options);
-            return data ?? (await this.getLeagueWar(clanTag));
+            return await this.getClanWar(args.clanTag, options);
         }
         catch (e) {
             if (e instanceof HTTPError_1.HTTPError && e.status === 403) {
-                return this.getLeagueWar(clanTag);
+                return this.getLeagueWar({ clanTag: args.clanTag, round: args.round });
             }
         }
         return null;
     }
-    /** Get info about currently running CWL round. */
-    async getLeagueWar(clanTag, warState) {
-        const state = (warState && exports.CWLRound[warState]) ?? 'inWar'; // eslint-disable-line
-        const data = await this.getClanWarLeagueGroup(clanTag);
+    /**
+     * 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;
@@ -95,8 +117,11 @@ class Client extends events_1.EventEmitter {
             .map((round) => round.warTags)
             .flat()
             .reverse();
-        const wars = await this.util.allSettled(warTags.map((warTag) => this.getClanWarLeagueRound({ warTag, clanTag }, { ignoreRateLimit: true })));
-        return wars.find((war) => war?.state === state) ?? wars.at(0) ?? null;
+        const wars = await this.util.allSettled(warTags.map((warTag) => this.getClanWarLeagueRound({ warTag, clanTag: args.clanTag }, { 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);
@@ -106,15 +131,12 @@ class Client extends events_1.EventEmitter {
     async _getClanWars(clanTag, options) {
         const date = new Date().getDate();
         try {
-            const data = await this.getClanWar(clanTag, options);
-            if (!(date >= 1 && date <= 10))
-                return data ? [data] : [];
-            return data ? [data] : await this._getCurrentLeagueWars(clanTag);
+            return [await this.getClanWar(clanTag, options)];
         }
         catch (e) {
             if (!(date >= 1 && date <= 10))
                 return [];
-            if (e instanceof HTTPError_1.HTTPError && e.status === 403) {
+            if (e instanceof HTTPError_1.HTTPError && [200, 403].includes(e.status)) {
                 return this._getCurrentLeagueWars(clanTag);
             }
             return [];
@@ -128,9 +150,10 @@ class Client extends events_1.EventEmitter {
     /** Get information about CWL round by WarTag. */
     async getClanWarLeagueRound(warTag, options) {
         const args = typeof warTag === 'string' ? { warTag } : { warTag: warTag.warTag, clanTag: warTag.clanTag };
-        const { data, maxAge } = await this.rest.getClanWarLeagueRound(args.warTag, options);
-        if (data.state === 'notInWar')
-            return null;
+        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. */
@@ -206,8 +229,3 @@ class Client extends events_1.EventEmitter {
     }
 }
 exports.Client = Client;
-exports.CWLRound = {
-    PREVIOUS_WAR: 'warEnded',
-    CURRENT_WAR: 'inWar',
-    NEXT_WAR: 'preparation'
-};

package/dist/client/EventManager.d.ts

@@ -1,4 +1,5 @@
-import { EventTypes, Client } from './Client';
+import { Clan, ClanWar, Player } from '../struct';
+import { Client } from './Client';
 /** Represents Event Manager of the {@link Client} class. */
 export declare class EventManager {
     private readonly client;
@@ -13,25 +14,29 @@ export declare class EventManager {
     private _maintenanceStartTime;
     constructor(client: Client);
     /** Initialize the Event Manager to start pulling. */
-    init(): Promise<(string | symbol)[]>;
+    init(): Promise<string[]>;
+    /** Add a clan tag to clan events. */
     addClans(...tags: string[]): this;
+    /** Delete a clan tag from clan events. */
     deleteClans(...tags: string[]): this;
+    /** Add a player tag for player events. */
     addPlayers(...tags: string[]): this;
+    /** Delete a player tag from player events. */
     deletePlayers(...tags: string[]): this;
+    /** Add a clan tag for war events. */
     addWars(...tags: string[]): this;
+    /** Delete a clan tag from war events. */
     deleteWars(...tags: string[]): this;
     /**
-     * Set your own custom event.
-     * @param event.type - `CLAN` | `PLAYER` | `CLAN_WAR`
-     * @param event.name - Name of the event.
-     * @param event.filter - Filter of this event. Must return a boolean value.
+     * Set your own custom clan event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
      *
      * @example
      * ```js
-     * client.events.addClans(['#2PP', '']);
+     * client.events.addClans(['#2PP', '#8QU8J9LP']);
      *
-     * client.events.setEvent({
-     *   type: 'CLAN',
+     * client.events.setClanEvent({
      *   name: 'clanMemberUpdate',
      *   filter: (oldClan, newClan) => {
      *     return oldClan.memberCount !== newClan.memberCount;
@@ -40,14 +45,35 @@ export declare class EventManager {
      *
      * client.on('clanMemberUpdate', (oldClan, newClan) => {
      *   console.log(oldClan.memberCount, newClan.memberCount);
-     * })
+     * });
+     *
+     * (async function () {
+     *   await client.events.init();
+     * })();
      * ```
      * @returns
      */
-    setEvent<K extends keyof EventTypes>(event: {
-        type: K;
+    setClanEvent(event: {
+        name: string;
+        filter: (oldClan: Clan, newClan: Clan) => boolean;
+    }): this;
+    /**
+     * Set your own custom war event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     */
+    setWarEvent(event: {
+        name: string;
+        filter: (oldWar: ClanWar, newWar: ClanWar) => boolean;
+    }): this;
+    /**
+     * Set your own custom player event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     */
+    setPlayerEvent(event: {
         name: string;
-        filter: (...args: EventTypes[K]) => boolean;
+        filter: (oldPlayer: Player, newPlayer: Player) => boolean;
     }): this;
     private maintenanceHandler;
     private seasonEndHandler;

package/dist/client/EventManager.js

@@ -31,36 +31,42 @@ class EventManager {
         this.warUpdateHandler();
         return Promise.resolve(this.client.eventNames());
     }
+    /** Add a clan tag to clan events. */
     addClans(...tags) {
         for (const tag of tags) {
             this._clanTags.add(this.client.util.parseTag(tag));
         }
         return this;
     }
+    /** Delete a clan tag from clan events. */
     deleteClans(...tags) {
         for (const tag of tags) {
             this._warTags.delete(this.client.util.parseTag(tag));
         }
         return this;
     }
+    /** Add a player tag for player events. */
     addPlayers(...tags) {
         for (const tag of tags) {
             this._playerTags.add(this.client.util.parseTag(tag));
         }
         return this;
     }
+    /** Delete a player tag from player events. */
     deletePlayers(...tags) {
         for (const tag of tags) {
             this._warTags.delete(this.client.util.parseTag(tag));
         }
         return this;
     }
+    /** Add a clan tag for war events. */
     addWars(...tags) {
         for (const tag of tags) {
             this._warTags.add(this.client.util.parseTag(tag));
         }
         return this;
     }
+    /** Delete a clan tag from war events. */
     deleteWars(...tags) {
         for (const tag of tags) {
             this._warTags.delete(this.client.util.parseTag(tag));
@@ -68,17 +74,15 @@ class EventManager {
         return this;
     }
     /**
-     * Set your own custom event.
-     * @param event.type - `CLAN` | `PLAYER` | `CLAN_WAR`
-     * @param event.name - Name of the event.
-     * @param event.filter - Filter of this event. Must return a boolean value.
+     * Set your own custom clan event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
      *
      * @example
      * ```js
-     * client.events.addClans(['#2PP', '']);
+     * client.events.addClans(['#2PP', '#8QU8J9LP']);
      *
-     * client.events.setEvent({
-     *   type: 'CLAN',
+     * client.events.setClanEvent({
      *   name: 'clanMemberUpdate',
      *   filter: (oldClan, newClan) => {
      *     return oldClan.memberCount !== newClan.memberCount;
@@ -87,27 +91,34 @@ class EventManager {
      *
      * client.on('clanMemberUpdate', (oldClan, newClan) => {
      *   console.log(oldClan.memberCount, newClan.memberCount);
-     * })
+     * });
+     *
+     * (async function () {
+     *   await client.events.init();
+     * })();
      * ```
      * @returns
      */
-    setEvent(event) {
-        switch (event.type) {
-            case 'CLAN':
-                // @ts-expect-error
-                this._events.clans.push(event);
-                break;
-            case 'PLAYER':
-                // @ts-expect-error
-                this._events.players.push(event);
-                break;
-            case 'CLAN_WAR':
-                // @ts-expect-error
-                this._events.wars.push(event);
-                break;
-            default:
-                break;
-        }
+    setClanEvent(event) {
+        this._events.clans.push({ name: event.name, fn: event.filter });
+        return this;
+    }
+    /**
+     * Set your own custom war event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     */
+    setWarEvent(event) {
+        this._events.wars.push({ name: event.name, fn: event.filter });
+        return this;
+    }
+    /**
+     * Set your own custom player event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     */
+    setPlayerEvent(event) {
+        this._events.players.push({ name: event.name, fn: event.filter });
         return this;
     }
     async maintenanceHandler() {

package/dist/rest/HTTPError.d.ts

@@ -1,8 +1,26 @@
-/** Represents an HTTP Error. */
+/**
+ * Represents an HTTP Error.
+ */
 export declare class HTTPError extends Error {
+    /** The message of this error. */
+    message: string;
+    /** The HTTP method of this request. */
     method: string;
+    /** The reason of this error. */
     reason: string;
+    /** The HTTP status code of this request. */
     status: number;
+    /** The path of this request. */
     path: string;
-    constructor(error: any, status: number, path: string, method?: string);
+    /** Maximum number of milliseconds the results can be cached. */
+    maxAge: number;
+    constructor(error: any, status: number, path: string, maxAge: number, method?: string);
 }
+export declare const notInWarError: {
+    message: string;
+    reason: string;
+};
+export declare const privateWarLogError: {
+    message: string;
+    reason: string;
+};

package/dist/rest/HTTPError.js

@@ -1,23 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTPError = void 0;
+exports.privateWarLogError = exports.notInWarError = exports.HTTPError = void 0;
 const messages = {
-    504: 'The user aborted a request.',
-    404: 'Resource was not found.'
+    500: 'Unknown error happened when handling the request.',
+    504: 'The user aborted this request.',
+    404: 'Requested resource was not found.',
+    400: 'Client provided incorrect parameters for the request.',
+    503: 'Service is temporarily unavailable because of maintenance.',
+    429: 'Request was throttled, because amount of requests was above the threshold defined for the used API token.',
+    403: 'Access denied, either because of missing/incorrect credentials or used API token does not grant access to the requested resource.'
 };
 const reasons = {
-    504: 'networkTimeout',
-    404: 'notFound'
+    503: 'serviceUnavailable',
+    429: 'tooManyRequests',
+    400: 'badRequest',
+    403: 'forbidden',
+    500: 'unknownError',
+    404: 'notFound',
+    504: 'requestAborted'
 };
-/** Represents an HTTP Error. */
+/**
+ * Represents an HTTP Error.
+ */
 class HTTPError extends Error {
-    constructor(error, status, path, method = 'GET') {
+    constructor(error, status, path, maxAge, method) {
         super();
         this.message = error?.message ?? messages[status];
         this.reason = error?.reason ?? reasons[status];
         this.path = path;
-        this.method = method;
+        this.method = method ?? 'GET';
         this.status = status;
+        this.maxAge = maxAge;
     }
 }
 exports.HTTPError = HTTPError;
+exports.notInWarError = {
+    message: 'Clan is not in war at this moment.',
+    reason: 'notInWar'
+};
+exports.privateWarLogError = {
+    message: 'Access denied, clan war log is private.',
+    reason: 'privateWarLog'
+};

package/dist/rest/RESTManager.d.ts

@@ -8,120 +8,144 @@ export declare class RESTManager {
         data: APIClanList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getClan(clanTag: string, options?: OverrideOptions): Promise<{
         data: APIClan;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getClanMembers(clanTag: string, options?: SearchOptions): Promise<{
         data: APIClanMemberList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getClanWarLog(clanTag: string, options?: SearchOptions): Promise<{
         data: APIClanWarLog;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getCurrentWar(clanTag: string, options?: OverrideOptions): Promise<{
         data: APIClanWar;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getClanWarLeagueGroup(clanTag: string, options?: OverrideOptions): Promise<{
         data: APIClanWarLeagueGroup;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getClanWarLeagueRound(warTag: string, options?: OverrideOptions): Promise<{
         data: APIClanWar;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getPlayer(playerTag: string, options?: OverrideOptions): Promise<{
         data: APIPlayer;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     postPlayerToken(playerTag: string, token: string, options?: OverrideOptions): Promise<{
         data: APIVerifyToken;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getLeagues(options?: SearchOptions): Promise<{
         data: APILeagueList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getLeague(leagueId: string | number, options?: OverrideOptions): Promise<{
         data: APILeague;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getLeagueSeasons(leagueId: number, options?: SearchOptions): Promise<{
         data: APILeagueSeasonList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getSeasonRankings(leagueId: number, seasonId: string, options?: SearchOptions): Promise<{
         data: APIPlayerSeasonRankingList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getWarLeagues(options?: SearchOptions): Promise<{
         data: APIWarLeagueList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getWarLeague(leagueId: number, options?: OverrideOptions): Promise<{
         data: APIWarLeague;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getLocations(options?: SearchOptions): Promise<{
         data: APILocationList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getLocation(locationId: number, options?: OverrideOptions): Promise<{
         data: APILocation;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getClanRanks(locationId: number | string, options?: SearchOptions): Promise<{
         data: APIClanRankingList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getPlayerRanks(locationId: number | string, options?: SearchOptions): Promise<{
         data: APIPlayerRankingList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getVersusClanRanks(locationId: number | string, options?: SearchOptions): Promise<{
         data: APIClanVersusRankingList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getVersusPlayerRanks(locationId: number | string, options?: SearchOptions): Promise<{
         data: APIPlayerVersusRankingList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getClanLabels(options?: SearchOptions): Promise<{
         data: APILabelList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getPlayerLabels(options?: SearchOptions): Promise<{
         data: APILabelList;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     getGoldPassSeason(options?: OverrideOptions): Promise<{
         data: APIGoldPassSeason;
         maxAge: number;
         status: number;
+        path: string;
     }>;
 }

package/dist/rest/RequestHandler.d.ts

@@ -1,4 +1,5 @@
 import { QueueThrottler, BatchThrottler } from './Throttler';
+import Keyv from 'keyv';
 /** Represents a Request Handler. */
 export declare class RequestHandler {
     #private;
@@ -6,7 +7,7 @@ export declare class RequestHandler {
     private password;
     private keyCount;
     private keyName;
-    private keyDescription;
+    private keyDescription?;
     private keys;
     private readonly baseURL;
     private readonly retryLimit;
@@ -21,54 +22,134 @@ export declare class RequestHandler {
         data: T;
         maxAge: number;
         status: number;
+        path: string;
     }>;
     private exec;
     init(options: InitOptions): Promise<string[]>;
+    private reValidateKeys;
     private login;
     private getKeys;
     private revokeKey;
     private createKey;
     private getIp;
 }
+/** Options for a client. */
 export interface ClientOptions {
+    /** Keys from Clash of Clans API developer site. */
     keys?: string[];
-    cache?: boolean;
+    /** Base URL of the Clash of Clans API. */
     baseURL?: string;
+    /**
+     * How many times to retry on 5XX errors.
+     */
     retryLimit?: number;
+    /**
+     * Whether enable or disable internal caching.
+     * @example
+     * ```ts
+     * const client = new Client({ cache: true });
+     * ```
+     */
+    cache?: boolean | Keyv;
+    /** Time to wait before cancelling a REST request, in milliseconds. */
     restRequestTimeout?: number;
+    /**
+     * Throttler class which handles rate-limit
+     * @example
+     * ```ts
+     * const client = new Client({ throttler: new QueueThrottler(1000 / 10) });
+     * ```
+     * @example
+     * ```ts
+     * const client = new Client({ throttler: new BatchThrottler(30) });
+     * ```
+     */
     throttler?: QueueThrottler | BatchThrottler;
 }
+/** Search options for request. */
 export interface SearchOptions extends OverrideOptions {
+    /** Limit the number of items returned in the response. */
     limit?: number;
+    /**
+     * Return only items that occur after this marker.
+     * Before marker can be found from the response, inside the 'paging' property.
+     * Note that only after or before can be specified for a request, not both.
+     */
     after?: string;
+    /**
+     * Return only items that occur before this marker.
+     * Before marker can be found from the response, inside the 'paging' property.
+     * Note that only after or before can be specified for a request, not both.
+     */
     before?: string;
 }
+/** Override options for a request. */
 export interface OverrideOptions {
+    /** Whether to cache this response. */
+    cache?: boolean;
+    /** Whether to skip the cache check and request the API. */
+    force?: boolean;
+    /** How many times to retry on 5XX errors. */
     retryLimit?: string;
+    /** Whether to ignore throttlers. */
     ignoreRateLimit?: boolean;
+    /** Time to wait before cancelling a REST request, in milliseconds. */
     restRequestTimeout?: number;
 }
 export interface RequestOptions extends OverrideOptions {
     body?: string;
     method?: string;
 }
+/**
+ * Clan search options for a request.
+ *
+ * ::info
+ * If name is used as part of search query, it needs to be at least three characters long.
+ * Name search parameter is interpreted as wild card search, so it may appear anywhere in the clan name.
+ * :::
+ */
 export interface ClanSearchOptions {
+    /** Search clans by name. */
     name?: string;
+    /** Filter by minimum number of clan members. */
     minMembers?: number;
+    /** Filter by maximum number of clan members. */
     maxMembers?: number;
+    /** Filter by minimum amount of clan points. */
     minClanPoints?: number;
+    /** Filter by minimum clan level. */
     minClanLevel?: number;
+    /** Filter by clan war frequency. */
     warFrequency?: string;
+    /** Filter by clan location identifier. For list of available locations, refer to getLocations operation. */
     locationId?: string;
+    /** Comma separated list of label IDs to use for filtering results. */
     labelIds?: string;
+    /** Limit the number of items returned in the response. */
     limit?: number;
+    /**
+     * Return only items that occur after this marker.
+     * Before marker can be found from the response, inside the 'paging' property.
+     * Note that only after or before can be specified for a request, not both.
+     */
     after?: string;
+    /**
+     * Return only items that occur before this marker.
+     * Before marker can be found from the response, inside the 'paging' property.
+     * Note that only after or before can be specified for a request, not both.
+     */
     before?: string;
 }
+/** Login options for a client. */
 export interface InitOptions {
+    /** Developer site email address. */
     email: string;
+    /** Developer site password. */
     password: string;
+    /** Name of API key(s). */
     keyName?: string;
+    /** Number of allowed API keys. */
     keyCount?: number;
+    /** Description of API key(s). */
     keyDescription?: string;
 }

package/dist/rest/RequestHandler.js

@@ -30,8 +30,11 @@ class RequestHandler {
         this.retryLimit = options?.retryLimit ?? 0;
         this.throttler = options?.throttler ?? null;
         this.baseURL = options?.baseURL ?? Constants_1.API_BASE_URL;
-        this.cached = options?.cache ? new keyv_1.default() : null;
         this.restRequestTimeout = options?.restRequestTimeout ?? 0;
+        if (options?.cache instanceof keyv_1.default)
+            this.cached = options.cache;
+        else
+            this.cached = options?.cache ? new keyv_1.default() : null;
     }
     get _keys() {
         return Array.isArray(this.keys) ? this.keys : [this.keys];
@@ -47,8 +50,8 @@ class RequestHandler {
     }
     async request(path, options = {}) {
         const cached = (await this.cached?.get(path)) ?? null;
-        if (cached)
-            return { data: cached, maxAge: 0, status: 200 };
+        if (cached && options.force !== true)
+            return { data: cached, maxAge: 0, status: 200, path };
         if (!this.throttler || options.ignoreRateLimit)
             return this.exec(path, options);
         await this.throttler.wait();
@@ -74,23 +77,40 @@ class RequestHandler {
             await this.login();
             return this.exec(path, options, ++retries);
         }
+        const maxAge = Number(res?.headers.get('cache-control')?.split('=')?.[1] ?? 0) * 1000;
+        if (res?.status === 403 && !data?.message)
+            throw new HTTPError_1.HTTPError(HTTPError_1.privateWarLogError, res.status, path, maxAge);
         if (!res?.ok)
-            throw new HTTPError_1.HTTPError(data, res?.status ?? 504, path, options.method);
-        const maxAge = Number(res.headers.get('cache-control')?.split('=')?.[1] ?? 0) * 1000;
-        if (this.cached && maxAge > 0)
+            throw new HTTPError_1.HTTPError(data, res?.status ?? 504, path, maxAge, options.method);
+        if (this.cached && maxAge > 0 && options.cache !== false)
             await this.cached.set(path, data, maxAge);
-        return { data, maxAge, status: res.status };
+        return { data, maxAge, status: res.status, path };
     }
-    init(options) {
+    async init(options) {
         if (!(options.email && options.password))
             throw ReferenceError('Missing email and password.');
-        this.keyDescription = options.keyDescription ?? new Date().toUTCString();
+        this.keyDescription = options.keyDescription;
         this.keyName = options.keyName ?? 'clashofclans.js.keys';
         this.keyCount = Math.min(options.keyCount ?? 1, 10);
         this.password = options.password;
         this.email = options.email;
+        await this.reValidateKeys();
         return this.login();
     }
+    async reValidateKeys() {
+        for (const key of this.keys) {
+            const res = await (0, node_fetch_1.default)(`${this.baseURL}/locations?limit=1`, {
+                method: 'GET',
+                timeout: 10000,
+                headers: { 'Authorization': `Bearer ${key}`, 'Content-Type': 'application/json' }
+            }).catch(() => null);
+            if (res?.status === 403) {
+                const index = this.keys.indexOf(key);
+                this.keys.splice(index, 1);
+                console.warn(`[WARN] Pre-defined key #${index + 1} is no longer valid. Removed from the key list.`);
+            }
+        }
+    }
     async login() {
         const res = await (0, node_fetch_1.default)(`${Constants_1.DEV_SITE_API_BASE_URL}/login`, {
             method: 'POST',
@@ -120,9 +140,12 @@ class RequestHandler {
             keys.splice(index, 1);
         }
         // Filter keys for current IP address and specified key name.
-        const matching = keys.filter((key) => key.name === this.keyName && key.cidrRanges.includes(ip));
-        if (matching.length)
-            this.keys.push(...matching.map((key) => key.key).slice(0, this.keyCount));
+        for (const key of keys.filter((key) => key.name === this.keyName && key.cidrRanges.includes(ip))) {
+            if (this.keys.length >= this.keyCount)
+                break;
+            if (!this.keys.includes(key.key))
+                this.keys.push(key.key);
+        }
         // Create keys within limits (maximum of 10 keys per account)
         while (this.keys.length < this.keyCount && keys.length < 10) {
             const key = await this.createKey(cookie, ip);
@@ -152,7 +175,11 @@ class RequestHandler {
         const res = await (0, node_fetch_1.default)(`${Constants_1.DEV_SITE_API_BASE_URL}/apikey/create`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', cookie },
-            body: JSON.stringify({ cidrRanges: [ip], name: this.keyName, description: this.keyDescription })
+            body: JSON.stringify({
+                cidrRanges: [ip],
+                name: this.keyName,
+                description: this.keyDescription ?? new Date().toUTCString()
+            })
         });
         const data = await res.json();
         return data.key;

package/dist/struct/ClanWar.d.ts

@@ -116,12 +116,12 @@ export declare class ClanWar {
     opponent: WarClan;
     /** The war's unique tag. This is `null` unless this is a CWL.  */
     warTag: string | null;
-    /** The timestamp when a fresh version of this data will be available again. */
+    /** Maximum number of milliseconds the results can be cached. */
     maxAge: number;
     constructor(client: Client, data: APIClanWar, extra: {
         clanTag?: string;
         warTag?: string;
-        maxAge?: number;
+        maxAge: number;
     });
     /** Return a {@link ClanWarMember} with the tag provided. */
     getMember(tag: string): ClanWarMember | null;
@@ -129,7 +129,9 @@ export declare class ClanWar {
     getAttack(attackerTag: string, defenderTag: string): ClanWarAttack | null;
     /** Return a list of {@link ClanWarAttack} for the defenderTag provided. */
     getDefenses(defenderTag: string): ClanWarAttack[];
-    /** Returns either `friendly`, `cwl` or `regular`. */
-    get type(): 'friendly' | 'cwl' | 'regular';
+    /** Returns either `friendly`, `cwl` or `normal`. */
+    get type(): "friendly" | "cwl" | "normal";
     private get _isFriendly();
+    /** Returns the war status, based off the home clan. */
+    get status(): "win" | "lose" | "tie" | "pending";
 }

package/dist/struct/ClanWar.js

@@ -147,7 +147,7 @@ class ClanWar {
         }
         this.clan = new WarClan(this, clan);
         this.opponent = new WarClan(this, opponent);
-        this.maxAge = Date.now() + (extra.maxAge ?? 0);
+        this.maxAge = extra.maxAge;
     }
     /** Return a {@link ClanWarMember} with the tag provided. */
     getMember(tag) {
@@ -168,17 +168,31 @@ class ClanWar {
         }
         return this.opponent.attacks.filter((atk) => atk.defenderTag === defenderTag);
     }
-    /** Returns either `friendly`, `cwl` or `regular`. */
+    /** Returns either `friendly`, `cwl` or `normal`. */
     get type() {
         if (this._isFriendly)
             return 'friendly';
         if (this.warTag)
             return 'cwl';
-        return 'regular';
+        return 'normal';
     }
     get _isFriendly() {
         const preparationTime = this.startTime.getTime() - this.preparationStartTime.getTime();
         return Constants_1.FRIENDLY_WAR_PREPARATION_TIMES.includes(preparationTime);
     }
+    /** Returns the war status, based off the home clan. */
+    get status() {
+        if (this.state === 'preparation')
+            return 'pending';
+        if (this.clan.stars > this.opponent.stars)
+            return 'win';
+        if (this.clan.stars === this.opponent.stars) {
+            if (this.clan.destruction > this.opponent.destruction)
+                return 'win';
+            if (this.clan.destruction === this.opponent.destruction)
+                return 'tie';
+        }
+        return 'lose';
+    }
 }
 exports.ClanWar = ClanWar;

package/dist/struct/ClanWarLeagueGroup.js

@@ -57,7 +57,7 @@ class ClanWarLeagueGroup {
         const warTags = rounds.map((round) => round.warTags).flat();
         const wars = await Promise.allSettled(warTags.map((warTag) => this.client.getClanWarLeagueRound({ warTag, clanTag }, { ignoreRateLimit: true })));
         return wars
-            .filter((res) => res.status === 'fulfilled' && res.value)
+            .filter((res) => res.status === 'fulfilled')
             .map((res) => res.value)
             .filter((war) => (clanTag ? war.clan.tag === clanTag : true));
     }
@@ -71,7 +71,7 @@ class ClanWarLeagueGroup {
             .flat();
         const wars = await Promise.allSettled(warTags.map((warTag) => this.client.getClanWarLeagueRound({ warTag, clanTag }, { ignoreRateLimit: true })));
         return wars
-            .filter((res) => res.status === 'fulfilled' && res.value)
+            .filter((res) => res.status === 'fulfilled')
             .map((res) => res.value)
             .filter((war) => war.clan.tag === clanTag);
     }

package/dist/struct/ClanWarLog.d.ts

@@ -49,6 +49,6 @@ export declare class ClanWarLog {
     /** The opposition clan. */
     opponent: WarLogClan;
     constructor(client: Client, data: APIClanWarLogEntry);
-    /** Returns either `friendly`, `cwl` or `regular`. */
-    get type(): "friendly" | "cwl" | "regular";
+    /** Returns either `friendly`, `cwl` or `normal`. */
+    get type(): "friendly" | "cwl" | "normal";
 }

package/dist/struct/ClanWarLog.js

@@ -34,13 +34,13 @@ class ClanWarLog {
         this.clan = new WarLogClan(data.clan);
         this.opponent = new WarLogClan(data.opponent);
     }
-    /** Returns either `friendly`, `cwl` or `regular`. */
+    /** Returns either `friendly`, `cwl` or `normal`. */
     get type() {
         if (!this.clan.expEarned)
             return 'friendly';
         if (!this.opponent.tag)
             return 'cwl';
-        return 'regular';
+        return 'normal';
     }
 }
 exports.ClanWarLog = ClanWarLog;

package/dist/types/index.d.ts

@@ -230,7 +230,7 @@ export interface APILocationList {
     items: APILocation[];
     paging: APIPaging;
 }
-/** /locations/{loacationId} */
+/** /locations/{locationId} */
 export interface APILocation {
     localizedName?: string;
     id: number;

package/dist/util/Constants.d.ts

@@ -34,3 +34,8 @@ export declare const EVENTS: {
     readonly MAINTENANCE_END: "maintenanceEnd";
     readonly ERROR: "error";
 };
+export declare const CWL_ROUNDS: {
+    readonly PREVIOUS_ROUND: "warEnded";
+    readonly CURRENT_ROUND: "inWar";
+    readonly NEXT_ROUND: "preparation";
+};

package/dist/util/Constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVENTS = exports.FRIENDLY_WAR_PREPARATION_TIMES = exports.WAR_LEAGUES = exports.LEAGUES = exports.LEGEND_LEAGUE_ID = exports.UNRANKED_LEAGUE_DATA = exports.HERO_PETS = exports.HEROES = exports.SPELLS = exports.DARK_ELIXIR_SPELLS = exports.ELIXIR_SPELLS = exports.SUPER_TROOPS = exports.SIEGE_MACHINES = exports.HOME_TROOPS = exports.DARK_ELIXIR_TROOPS = exports.ELIXIR_TROOPS = exports.DEV_SITE_API_BASE_URL = exports.API_BASE_URL = void 0;
+exports.CWL_ROUNDS = exports.EVENTS = exports.FRIENDLY_WAR_PREPARATION_TIMES = exports.WAR_LEAGUES = exports.LEAGUES = exports.LEGEND_LEAGUE_ID = exports.UNRANKED_LEAGUE_DATA = exports.HERO_PETS = exports.HEROES = exports.SPELLS = exports.DARK_ELIXIR_SPELLS = exports.ELIXIR_SPELLS = exports.SUPER_TROOPS = exports.SIEGE_MACHINES = exports.HOME_TROOPS = exports.DARK_ELIXIR_TROOPS = exports.ELIXIR_TROOPS = exports.DEV_SITE_API_BASE_URL = exports.API_BASE_URL = void 0;
 exports.API_BASE_URL = 'https://api.clashofclans.com/v1';
 exports.DEV_SITE_API_BASE_URL = 'https://developer.clashofclans.com/api';
 exports.ELIXIR_TROOPS = [
@@ -115,3 +115,8 @@ exports.EVENTS = {
     MAINTENANCE_END: 'maintenanceEnd',
     ERROR: 'error'
 };
+exports.CWL_ROUNDS = {
+    PREVIOUS_ROUND: 'warEnded',
+    CURRENT_ROUND: 'inWar',
+    NEXT_ROUND: 'preparation'
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "clashofclans.js",
-	"version": "2.0.0-dev.7f4d9f8",
+	"version": "2.0.0-dev.86dfaef",
 	"description": "JavaScript library for interacting with the Clash of Clans API",
 	"author": "SUVAJIT <suvajit.me@gmail.com>",
 	"license": "MIT",