clashofclans.js 2.8.2 → 3.0.0-dev.29c3270

package/dist/client/{EventManager.js → PollingClient.js}

@@ -1,79 +1,85 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventManager = void 0;
+exports.PollingClient = void 0;
 const HTTPError_1 = require("../rest/HTTPError");
 const Constants_1 = require("../util/Constants");
-const Util_1 = require("../util/Util");
-/** Represents Event Manager of the {@link Client}. */
-class EventManager {
-    constructor(client) {
-        this.client = client;
+const Client_1 = require("./Client");
+/**
+ * Represents Clash of Clans Polling Event Client.
+ * ```js
+ * const { PollingClient } = require('clashofclans.js');
+ * const client = new PollingClient({ keys: ['***'] });
+ * ```
+ */
+class PollingClient extends Client_1.Client {
+    constructor(options) {
+        super(options);
         this._clanTags = new Set();
         this._playerTags = new Set();
         this._warTags = new Set();
         this._clans = new Map();
         this._players = new Map();
         this._wars = new Map();
-        this._events = {
+        this._pollingEvents = {
             clans: [],
             wars: [],
             players: []
         };
-        this._inMaintenance = Boolean(false);
+        this.inMaintenance = Boolean(false);
         this._maintenanceStartTime = null;
     }
-    /** Initialize the Event Manager to start pulling. */
+    /** Initialize the PollingEvent Manager to start pulling the data by polling api. */
     async init() {
         this.seasonEndHandler();
         this.maintenanceHandler();
         this.clanUpdateHandler();
         this.playerUpdateHandler();
         this.warUpdateHandler();
-        return Promise.resolve(this.client.eventNames());
+        return Promise.resolve(this.eventNames());
     }
-    /** Add clan tags to clan events. */
+    /** Add clan tags to clan polling events. */
     addClans(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            this._clanTags.add(this.client.util.formatTag(tag));
+            this._clanTags.add(this.util.formatTag(tag));
         }
         return this;
     }
-    /** Delete clan tags from clan events. */
+    /** Delete clan tags from clan polling events. */
     deleteClans(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            const key = this.client.util.formatTag(tag);
+            const key = this.util.formatTag(tag);
             this._clans.delete(key);
             this._clanTags.delete(key);
         }
         return this;
     }
-    /** Add player tags for player events. */
+    /** Add player tags for player polling events. */
     addPlayers(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            this._playerTags.add(this.client.util.formatTag(tag));
+            this._playerTags.add(this.util.formatTag(tag));
         }
         return this;
     }
-    /** Delete player tags from player events. */
+    /** Delete player tags from player polling events. */
     deletePlayers(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            const key = this.client.util.formatTag(tag);
+            const key = this.util.formatTag(tag);
             this._players.delete(key);
             this._playerTags.delete(key);
         }
         return this;
     }
-    /** Add clan tags for war events. */
+    /** Add clan tags for war polling events. */
     addWars(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            this._warTags.add(this.client.util.formatTag(tag));
+            this._warTags.add(this.util.formatTag(tag));
         }
         return this;
     }
-    /** Delete clan tags from war events. */
+    /** Delete clan tags from war polling events. */
     deleteWars(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            const key = this.client.util.formatTag(tag);
+            const key = this.util.formatTag(tag);
             this._wars.delete(`${key}:${1}`);
             this._wars.delete(`${key}:${2}`);
             this._warTags.delete(key);
@@ -81,15 +87,15 @@ class EventManager {
         return this;
     }
     /**
-     * Set your own custom clan event.
+     * Set your own custom clan polling event.
      *
-     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     * In order to emit the custom polling event, you must have this filter function that returns a boolean.
      *
      * @example
      * ```js
-     * client.events.addClans(['#2PP', '#8QU8J9LP']);
+     * client.addClans(['#2PP', '#8QU8J9LP']);
      *
-     * client.events.setClanEvent({
+     * client.setClanEvent({
      *   name: 'clanMemberUpdate',
      *   filter: (oldClan, newClan) => {
      *     return oldClan.memberCount !== newClan.memberCount;
@@ -101,7 +107,7 @@ class EventManager {
      * });
      *
      * (async function () {
-     *   await client.events.init();
+     *   await client.init();
      * })();
      * ```
      * @returns
@@ -111,7 +117,7 @@ class EventManager {
             throw new Error('Event name is required.');
         if (typeof event.filter !== 'function')
             throw new Error('Filter function is required.');
-        this._events.clans.push(event);
+        this._pollingEvents.clans.push(event);
         return this;
     }
     /**
@@ -124,7 +130,7 @@ class EventManager {
             throw new Error('Event name is required.');
         if (typeof event.filter !== 'function')
             throw new Error('Filter function is required.');
-        this._events.wars.push(event);
+        this._pollingEvents.wars.push(event);
         return this;
     }
     /**
@@ -137,107 +143,107 @@ class EventManager {
             throw new Error('Event name is required.');
         if (typeof event.filter !== 'function')
             throw new Error('Filter function is required.');
-        this._events.players.push(event);
+        this._pollingEvents.players.push(event);
         return this;
     }
     async maintenanceHandler() {
         setTimeout(this.maintenanceHandler.bind(this), 10000).unref();
         try {
-            const res = await this.client.rest.getClans({ maxMembers: Math.floor(Math.random() * 40) + 10, limit: 1 });
-            if (res.status === 200 && this._inMaintenance) {
-                this._inMaintenance = Boolean(false);
+            const res = await this.rest.getClans({ maxMembers: Math.floor(Math.random() * 40) + 10, limit: 1 });
+            if (res.status === 200 && this.inMaintenance) {
+                this.inMaintenance = Boolean(false);
                 const duration = Date.now() - this._maintenanceStartTime.getTime();
                 this._maintenanceStartTime = null;
-                this.client.emit(Constants_1.EVENTS.MAINTENANCE_END, duration);
+                this.emit(Constants_1.PollingEvents.MaintenanceEnd, duration);
             }
         }
         catch (error) {
-            if (error instanceof HTTPError_1.HTTPError && error.status === 503 && !this._inMaintenance) {
-                this._inMaintenance = Boolean(true);
+            if (error instanceof HTTPError_1.HTTPError && error.status === 503 && !this.inMaintenance) {
+                this.inMaintenance = Boolean(true);
                 this._maintenanceStartTime = new Date();
-                this.client.emit(Constants_1.EVENTS.MAINTENANCE_START);
+                this.emit(Constants_1.PollingEvents.MaintenanceStart);
             }
         }
     }
     seasonEndHandler() {
-        const end = Util_1.Util.getSeasonEndTime().getTime() - Date.now();
+        const end = this.util.getSeasonEndTime().getTime() - Date.now();
         // Why this? setTimeout can be up to 24.8 days or 2147483647ms [(2^31 - 1) Max 32bit Integer]
         if (end > 24 * 60 * 60 * 1000) {
             setTimeout(this.seasonEndHandler.bind(this), 60 * 60 * 1000);
         }
         else if (end > 0) {
             setTimeout(() => {
-                this.client.emit(Constants_1.EVENTS.NEW_SEASON_START, Util_1.Util.getSeasonId());
+                this.emit(Constants_1.PollingEvents.NewSeasonStart, this.util.getSeasonId());
             }, end + 100).unref();
         }
     }
     async clanUpdateHandler() {
-        this.client.emit(Constants_1.EVENTS.CLAN_LOOP_START);
+        this.emit(Constants_1.PollingEvents.ClanLoopStart);
         for (const tag of this._clanTags)
             await this.runClanUpdate(tag);
-        this.client.emit(Constants_1.EVENTS.CLAN_LOOP_END);
+        this.emit(Constants_1.PollingEvents.ClanLoopEnd);
         setTimeout(this.clanUpdateHandler.bind(this), 10000);
     }
     async playerUpdateHandler() {
-        this.client.emit(Constants_1.EVENTS.PLAYER_LOOP_START);
+        this.emit(Constants_1.PollingEvents.PlayerLoopStart);
         for (const tag of this._playerTags)
             await this.runPlayerUpdate(tag);
-        this.client.emit(Constants_1.EVENTS.PLAYER_LOOP_END);
+        this.emit(Constants_1.PollingEvents.PlayerLoopEnd);
         setTimeout(this.playerUpdateHandler.bind(this), 10000);
     }
     async warUpdateHandler() {
-        this.client.emit(Constants_1.EVENTS.WAR_LOOP_START);
+        this.emit(Constants_1.PollingEvents.WarLoopStart);
         for (const tag of this._warTags)
             await this.runWarUpdate(tag);
-        this.client.emit(Constants_1.EVENTS.WAR_LOOP_END);
+        this.emit(Constants_1.PollingEvents.WarLoopEnd);
         setTimeout(this.warUpdateHandler.bind(this), 10000);
     }
     async runClanUpdate(tag) {
-        if (this._inMaintenance)
+        if (this.inMaintenance)
             return null;
-        const clan = await this.client.getClan(tag).catch(() => null);
+        const clan = await this.getClan(tag).catch(() => null);
         if (!clan)
             return null;
         const cached = this._clans.get(clan.tag);
         if (!cached)
             return this._clans.set(clan.tag, clan);
-        for (const { name, filter } of this._events.clans) {
+        for (const { name, filter } of this._pollingEvents.clans) {
             try {
                 if (!(await filter(cached, clan)))
                     continue;
-                this.client.emit(name, cached, clan);
+                this.emit(name, cached, clan);
             }
             catch (error) {
-                this.client.emit(Constants_1.EVENTS.ERROR, error);
+                this.emit(Constants_1.PollingEvents.Error, error);
             }
         }
         return this._clans.set(clan.tag, clan);
     }
     async runPlayerUpdate(tag) {
-        if (this._inMaintenance)
+        if (this.inMaintenance)
             return null;
-        const player = await this.client.getPlayer(tag).catch(() => null);
+        const player = await this.getPlayer(tag).catch(() => null);
         if (!player)
             return null;
         const cached = this._players.get(player.tag);
         if (!cached)
             return this._players.set(player.tag, player);
-        for (const { name, filter } of this._events.players) {
+        for (const { name, filter } of this._pollingEvents.players) {
             try {
                 if (!(await filter(cached, player)))
                     continue;
-                this.client.emit(name, cached, player);
+                this.emit(name, cached, player);
             }
             catch (error) {
-                this.client.emit(Constants_1.EVENTS.ERROR, error);
+                this.emit(Constants_1.PollingEvents.Error, error);
             }
         }
         return this._players.set(player.tag, player);
     }
     async runWarUpdate(tag) {
-        if (this._inMaintenance)
+        if (this.inMaintenance)
             return null;
-        const clanWars = await this.client.getWars(tag).catch(() => null);
+        const clanWars = await this.getWars(tag).catch(() => null);
         if (!clanWars?.length)
             return null;
         clanWars.forEach(async (war, index) => {
@@ -245,28 +251,28 @@ class EventManager {
             const cached = this._wars.get(key);
             if (!cached)
                 return this._wars.set(key, war);
-            for (const { name, filter } of this._events.wars) {
+            for (const { name, filter } of this._pollingEvents.wars) {
                 try {
                     if (!(await filter(cached, war)))
                         continue;
-                    this.client.emit(name, cached, war);
+                    this.emit(name, cached, war);
                 }
                 catch (error) {
-                    this.client.emit(Constants_1.EVENTS.ERROR, error);
+                    this.emit(Constants_1.PollingEvents.Error, error);
                 }
             }
             // check for war end
             if (index === 1 && cached.warTag !== war.warTag) {
-                const data = await this.client.getLeagueWar({ clanTag: tag, round: 'PREVIOUS_ROUND' }).catch(() => null);
+                const data = await this.getLeagueWar({ clanTag: tag, round: 'PreviousRound' }).catch(() => null);
                 if (data && data.warTag === cached.warTag) {
-                    for (const { name, filter } of this._events.wars) {
+                    for (const { name, filter } of this._pollingEvents.wars) {
                         try {
                             if (!(await filter(cached, data)))
                                 continue;
-                            this.client.emit(name, cached, data);
+                            this.emit(name, cached, data);
                         }
                         catch (error) {
-                            this.client.emit(Constants_1.EVENTS.ERROR, error);
+                            this.emit(Constants_1.PollingEvents.Error, error);
                         }
                     }
                 }
@@ -275,4 +281,4 @@ class EventManager {
         });
     }
 }
-exports.EventManager = EventManager;
+exports.PollingClient = PollingClient;

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export * from './client/Client';
+export * from './client/PollingClient';
 export * from './rest/RESTManager';
 export * from './rest/RequestHandler';
 export * from './rest/HTTPError';
-export * from './client/EventManager';
 export * from './rest/Throttler';
 export * from './util/Util';
 export * from './struct';

package/dist/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -11,10 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client/Client"), exports);
+__exportStar(require("./client/PollingClient"), exports);
 __exportStar(require("./rest/RESTManager"), exports);
 __exportStar(require("./rest/RequestHandler"), exports);
 __exportStar(require("./rest/HTTPError"), exports);
-__exportStar(require("./client/EventManager"), exports);
 __exportStar(require("./rest/Throttler"), exports);
 __exportStar(require("./util/Util"), exports);
 __exportStar(require("./struct"), exports);

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import mod from "./index.js";
 
 export default mod;
-export const API_BASE_URL = mod.API_BASE_URL;
+export const APIBaseURL = mod.APIBaseURL;
 export const Achievement = mod.Achievement;
-export const BUILDER_TROOPS = mod.BUILDER_TROOPS;
 export const Badge = mod.Badge;
 export const BatchThrottler = mod.BatchThrottler;
-export const CWL_ROUNDS = mod.CWL_ROUNDS;
+export const BuilderTroops = mod.BuilderTroops;
+export const CWLRounds = mod.CWLRounds;
 export const CacheStore = mod.CacheStore;
 export const ChatLanguage = mod.ChatLanguage;
 export const Clan = mod.Clan;
@@ -20,48 +20,50 @@ export const ClanWarLeagueRound = mod.ClanWarLeagueRound;
 export const ClanWarLog = mod.ClanWarLog;
 export const ClanWarMember = mod.ClanWarMember;
 export const Client = mod.Client;
-export const DARK_ELIXIR_SPELLS = mod.DARK_ELIXIR_SPELLS;
-export const DARK_ELIXIR_TROOPS = mod.DARK_ELIXIR_TROOPS;
-export const DEV_SITE_API_BASE_URL = mod.DEV_SITE_API_BASE_URL;
-export const ELIXIR_SPELLS = mod.ELIXIR_SPELLS;
-export const ELIXIR_TROOPS = mod.ELIXIR_TROOPS;
-export const EVENTS = mod.EVENTS;
-export const EventManager = mod.EventManager;
-export const FRIENDLY_WAR_PREPARATION_TIMES = mod.FRIENDLY_WAR_PREPARATION_TIMES;
+export const ClientEvents = mod.ClientEvents;
+export const DarkElixirSpells = mod.DarkElixirSpells;
+export const DarkElixirTroops = mod.DarkElixirTroops;
+export const DevSiteAPIBaseURL = mod.DevSiteAPIBaseURL;
+export const ElixirSpells = mod.ElixirSpells;
+export const ElixirTroops = mod.ElixirTroops;
+export const FriendlyWarPreparationTimes = mod.FriendlyWarPreparationTimes;
 export const GoldPassSeason = mod.GoldPassSeason;
-export const HEROES = mod.HEROES;
-export const HERO_PETS = mod.HERO_PETS;
-export const HOME_TROOPS = mod.HOME_TROOPS;
 export const HTTPError = mod.HTTPError;
 export const Hero = mod.Hero;
+export const HeroPets = mod.HeroPets;
+export const Heroes = mod.Heroes;
+export const HomeTroops = mod.HomeTroops;
 export const Icon = mod.Icon;
-export const LEAGUES = mod.LEAGUES;
-export const LEGEND_LEAGUE_ID = mod.LEGEND_LEAGUE_ID;
 export const Label = mod.Label;
 export const League = mod.League;
+export const Leagues = mod.Leagues;
+export const LegendLeagueId = mod.LegendLeagueId;
 export const LegendStatistics = mod.LegendStatistics;
 export const Location = mod.Location;
 export const NotInWarError = mod.NotInWarError;
 export const Player = mod.Player;
 export const PlayerClan = mod.PlayerClan;
+export const PollingClient = mod.PollingClient;
+export const PollingEvents = mod.PollingEvents;
 export const PrivateWarLogError = mod.PrivateWarLogError;
 export const QueueThrottler = mod.QueueThrottler;
-export const RAW_DATA = mod.RAW_DATA;
 export const RESTManager = mod.RESTManager;
 export const RankedClan = mod.RankedClan;
 export const RankedPlayer = mod.RankedPlayer;
+export const RawData = mod.RawData;
 export const RequestHandler = mod.RequestHandler;
-export const SIEGE_MACHINES = mod.SIEGE_MACHINES;
-export const SPELLS = mod.SPELLS;
-export const SUPER_TROOPS = mod.SUPER_TROOPS;
+export const RestEvents = mod.RestEvents;
 export const Season = mod.Season;
 export const SeasonRankedPlayer = mod.SeasonRankedPlayer;
+export const SiegeMachines = mod.SiegeMachines;
 export const Spell = mod.Spell;
+export const Spells = mod.Spells;
+export const SuperTroops = mod.SuperTroops;
 export const Troop = mod.Troop;
-export const UNRANKED_LEAGUE_DATA = mod.UNRANKED_LEAGUE_DATA;
 export const Unit = mod.Unit;
+export const UnrankedLeagueData = mod.UnrankedLeagueData;
 export const Util = mod.Util;
-export const WAR_LEAGUES = mod.WAR_LEAGUES;
 export const WarClan = mod.WarClan;
 export const WarLeague = mod.WarLeague;
+export const WarLeagues = mod.WarLeagues;
 export const WarLogClan = mod.WarLogClan;

package/dist/rest/RESTManager.d.ts

@@ -1,10 +1,43 @@
-import { RequestHandler } from './RequestHandler';
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
 import { Util } from '../util/Util';
 import { APIClan, APIClanList, APIClanMemberList, APIClanRankingList, APIClanVersusRankingList, APIClanWar, APIClanWarLeagueGroup, APIClanWarLog, APIGoldPassSeason, APILabelList, APILeague, APILeagueList, APILeagueSeasonList, APILocation, APILocationList, APIPlayer, APIPlayerRankingList, APIPlayerSeasonRankingList, APIPlayerVersusRankingList, APIVerifyToken, APIWarLeague, APIWarLeagueList, SearchOptions, ClanSearchOptions, RESTOptions, OverrideOptions, LoginOptions } from '../types';
+import { RestEvents } from '../util/Constants';
+import { RequestHandler } from './RequestHandler';
+export interface IRestEvents {
+    [RestEvents.Error]: [error: unknown];
+    [RestEvents.Debug]: [path: string, status: number, message: string];
+    [RestEvents.RateLimited]: [path: string, status: number, message: string];
+}
+export interface RESTManager {
+    emit: (<K extends keyof IRestEvents>(event: K, ...args: IRestEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, ...args: any[]) => boolean);
+    off: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    on: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    once: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    removeAllListeners: (<K extends keyof IRestEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof IRestEvents>) => this);
+    /**
+     * Emitted for general debugging information.
+     * @public
+     * @event
+     */
+    debug: string;
+    /**
+     * Emitted when the client encounters an error.
+     * @public
+     * @event
+     */
+    error: string;
+    /**
+     * Emitted when the client is rate limited.
+     * @public
+     * @event
+     */
+    rateLimited: string;
+}
 /** Represents a REST Manager of the client. */
-export declare class RESTManager {
+export declare class RESTManager extends EventEmitter {
     /** Request Handler for the RESTManager. */
-    handler: RequestHandler;
+    requestHandler: RequestHandler;
     constructor(options?: RESTOptions);
     /** Contains various general-purpose utility methods. */
     get util(): typeof Util;