jp.ms.common.modules 1.0.34 → 1.0.36

package/src/modules/base-achievements/base-achievements.module.ts

@@ -29,22 +29,28 @@ import {
   UserWonManyTablesTournamentAppEvent,
   UserWonOneTableTournamentAppEvent,
   UserWonTheGameAppEvent,
-  Won3GamesAchievement, Won3ProfiAchievement,
-  WonOneTableTournament3TimesAchievement
+  Won3GamesAchievement,
+  Won3ProfiAchievement,
+  WonOneTableTournament3TimesAchievement,
 } from 'jp.ms.common.engine';
 import { AppScreenIconEnum } from 'jp.common.models';
 
 import { EventsBusAppSubscribeService } from '../event-bus/events-bus.app.subscribe.service';
 import { PlayersManagerService } from '../players-manager';
 
-
 @Global()
 @Module({
   imports: [
     MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
-    MongooseModule.forFeature([{ name: ActivityLog.name, schema: ActivityLogSchema }]),
-    MongooseModule.forFeature([{ name: Achievement.name, schema: AchievementSchema }]),
-    MongooseModule.forFeature([{ name: UsersAchievement.name, schema: UsersAchievementSchema }]),
+    MongooseModule.forFeature([
+      { name: ActivityLog.name, schema: ActivityLogSchema },
+    ]),
+    MongooseModule.forFeature([
+      { name: Achievement.name, schema: AchievementSchema },
+    ]),
+    MongooseModule.forFeature([
+      { name: UsersAchievement.name, schema: UsersAchievementSchema },
+    ]),
   ],
   providers: [
     UsersRepository,
@@ -62,105 +68,234 @@ export abstract class BaseAchievementsModule {
     protected readonly activityLogRepository: ActivityLogRepository,
     protected readonly achievementRepository: AchievementRepository,
     protected readonly usersAchievementRepository: UsersAchievementsRepository,
-  ) {
-  }
+  ) {}
 
-  async onModuleInit () {
-    this.eventsBusAppSubscribeService.subscribe(this.onHandleAppEvent);
+  onModuleInit() {
+    this.eventsBusAppSubscribeService.subscribe((event) => {
+      void this.onHandleAppEvent(event);
+    });
   }
 
-  protected async onHandleAppEvent (event: BaseAppEvent) {
+  protected async onHandleAppEvent(event: BaseAppEvent) {
     if (event instanceof BaseUserAppEvent) {
       const userId = event.userId;
       const player = this.playersManager.getPlayerById(userId);
       const foundUser = await this.usersRepository.findById(userId);
-      const allAchievements: Array<Achievement> = await this.achievementRepository.findAchievements();
-      const usersAchievements: Array<UsersAchievement> = await this.usersAchievementRepository.findAchivementsByUserId(userId);
+      const allAchievements: Array<Achievement> =
+        await this.achievementRepository.findAchievements();
+      const usersAchievements: Array<UsersAchievement> =
+        await this.usersAchievementRepository.findAchivementsByUserId(userId);
 
       if (!player || !foundUser) {
         throw new InternalServerErrorException();
       }
 
       if (event instanceof UserGotNewLevelAppEvent) {
-        // TODO подумать куда перенести LEVEL UP 
-        player.sendMessage(new SnackbarSendToPlayerWsEvent(
-          event.game,
-          AppScreenIconEnum.ARROW_UPWARD,
-          'level up',
-          'buttonText'
-        ));
-
-        if (this.userHasNoAchievement(usersAchievements, GotLevel3Achievement.code)) {
+        // TODO подумать куда перенести LEVEL UP
+        player.sendMessage(
+          new SnackbarSendToPlayerWsEvent(
+            event.game,
+            AppScreenIconEnum.ARROW_UPWARD,
+            'level up',
+            'buttonText',
+          ),
+        );
+
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            GotLevel3Achievement.code,
+          )
+        ) {
           if (new GotLevel3Achievement(event.newLevel).userGotAchievement()) {
-            this.giveAchievement(allAchievements, GotLevel3Achievement.code, foundUser, event.game);
+            void this.giveAchievement(
+              allAchievements,
+              GotLevel3Achievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
 
-        if (this.userHasNoAchievement(usersAchievements, GotLevel10Achievement.code)) {
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            GotLevel10Achievement.code,
+          )
+        ) {
           if (new GotLevel10Achievement(event.newLevel).userGotAchievement()) {
-            this.giveAchievement(allAchievements, GotLevel10Achievement.code, foundUser, event.game);
+            void this.giveAchievement(
+              allAchievements,
+              GotLevel10Achievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
-
       } else if (event instanceof UserPlayedTheGameAppEvent) {
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            Playd10GamesAchievement.code,
+          )
+        ) {
+          const playdGamesCount =
+            await this.activityLogRepository.getUserPlayedGamesCount(userId);
 
-        if (this.userHasNoAchievement(usersAchievements, Playd10GamesAchievement.code)) {
-          const playdGamesCount = await this.activityLogRepository.getUserPlayedGamesCount(userId);
-
-          if (new Playd10GamesAchievement(playdGamesCount).userGotAchievement()) {
-            this.giveAchievement(allAchievements, Playd10GamesAchievement.code, foundUser, event.game);
+          if (
+            new Playd10GamesAchievement(playdGamesCount).userGotAchievement()
+          ) {
+            void this.giveAchievement(
+              allAchievements,
+              Playd10GamesAchievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
       } else if (event instanceof UserWonTheGameAppEvent) {
-        if (this.userHasNoAchievement(usersAchievements, Won3GamesAchievement.code)) {
-          const wonGamesCount = await this.activityLogRepository.getUserWonGamesCount(userId);
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            Won3GamesAchievement.code,
+          )
+        ) {
+          const wonGamesCount =
+            await this.activityLogRepository.getUserWonGamesCount(userId);
 
           if (new Won3GamesAchievement(wonGamesCount).userGotAchievement()) {
-            this.giveAchievement(allAchievements, Won3GamesAchievement.code, foundUser, event.game);
+            void this.giveAchievement(
+              allAchievements,
+              Won3GamesAchievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
 
-        if (this.userHasNoAchievement(usersAchievements, Won3ProfiAchievement.code)) {
-          const wonProfiCount = await this.activityLogRepository.getUserWonProfiCount(userId);
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            Won3ProfiAchievement.code,
+          )
+        ) {
+          const wonProfiCount =
+            await this.activityLogRepository.getUserWonProfiCount(userId);
           if (new Won3ProfiAchievement(wonProfiCount).userGotAchievement()) {
-            this.giveAchievement(allAchievements, Won3ProfiAchievement.code, foundUser, event.game);
+            void this.giveAchievement(
+              allAchievements,
+              Won3ProfiAchievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
 
-        if (this.userHasNoAchievement(usersAchievements, EarnOneMillionAchievement.code)) {
-          if (new EarnOneMillionAchievement(foundUser.balance).userGotAchievement()) {
-            this.giveAchievement(allAchievements, EarnOneMillionAchievement.code, foundUser, event.game);
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            EarnOneMillionAchievement.code,
+          )
+        ) {
+          if (
+            new EarnOneMillionAchievement(
+              foundUser.balance,
+            ).userGotAchievement()
+          ) {
+            void this.giveAchievement(
+              allAchievements,
+              EarnOneMillionAchievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
       } else if (event instanceof UserWonOneTableTournamentAppEvent) {
-        if (this.userHasNoAchievement(usersAchievements, WonOneTableTournament3TimesAchievement.code)) {
-          const wonFastTournamentCount = await this.activityLogRepository.getUserWonOneTableTournamentCount(userId);
-          if (new WonOneTableTournament3TimesAchievement(wonFastTournamentCount).userGotAchievement()) {
-            this.giveAchievement(allAchievements, WonOneTableTournament3TimesAchievement.code, foundUser, event.game);
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            WonOneTableTournament3TimesAchievement.code,
+          )
+        ) {
+          const wonFastTournamentCount =
+            await this.activityLogRepository.getUserWonOneTableTournamentCount(
+              userId,
+            );
+          if (
+            new WonOneTableTournament3TimesAchievement(
+              wonFastTournamentCount,
+            ).userGotAchievement()
+          ) {
+            void this.giveAchievement(
+              allAchievements,
+              WonOneTableTournament3TimesAchievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
       } else if (event instanceof UserWonManyTablesTournamentAppEvent) {
-        if (this.userHasNoAchievement(usersAchievements, Take1PlaceOnManyTablesTournamentAchievement.code)) {
-          if (new Take1PlaceOnManyTablesTournamentAchievement(event.rank)) {
-            this.giveAchievement(allAchievements, Take1PlaceOnManyTablesTournamentAchievement.code, foundUser, event.game);
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            Take1PlaceOnManyTablesTournamentAchievement.code,
+          )
+        ) {
+          if (
+            new Take1PlaceOnManyTablesTournamentAchievement(
+              event.rank,
+            ).userGotAchievement()
+          ) {
+            void this.giveAchievement(
+              allAchievements,
+              Take1PlaceOnManyTablesTournamentAchievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
 
-        if (this.userHasNoAchievement(usersAchievements, Take2Or3PlaceOnManyTablesTournamentAchievement.code)) {
-          if (new Take2Or3PlaceOnManyTablesTournamentAchievement(event.rank)) {
-            this.giveAchievement(allAchievements, Take2Or3PlaceOnManyTablesTournamentAchievement.code, foundUser, event.game);
+        if (
+          this.userHasNoAchievement(
+            usersAchievements,
+            Take2Or3PlaceOnManyTablesTournamentAchievement.code,
+          )
+        ) {
+          if (
+            new Take2Or3PlaceOnManyTablesTournamentAchievement(
+              event.rank,
+            ).userGotAchievement()
+          ) {
+            void this.giveAchievement(
+              allAchievements,
+              Take2Or3PlaceOnManyTablesTournamentAchievement.code,
+              foundUser,
+              event.game,
+            );
           }
         }
       }
     }
   }
 
-  protected userHasNoAchievement (usersAchievements: Array<UsersAchievement>, achievementCode: string) {
-    return !usersAchievements.find((item) => item.achievementCode === achievementCode);
+  protected userHasNoAchievement(
+    usersAchievements: Array<UsersAchievement>,
+    achievementCode: string,
+  ) {
+    return !usersAchievements.find(
+      (item) => item.achievementCode === achievementCode,
+    );
   }
 
-  protected async giveAchievement (allAchievements: Array<Achievement>, achievementCode: string, user: User, game: string) {
-    const foundAchievement = allAchievements.find((item) => item.code === achievementCode);
+  protected async giveAchievement(
+    allAchievements: Array<Achievement>,
+    achievementCode: string,
+    user: User,
+    game: string,
+  ) {
+    const foundAchievement = allAchievements.find(
+      (item) => item.code === achievementCode,
+    );
     const player = this.playersManager.getPlayerById(user.userId);
 
     if (foundAchievement && player) {
@@ -174,12 +309,14 @@ export abstract class BaseAchievementsModule {
         '',
       );
 
-      player.sendMessage(new SnackbarSendToPlayerWsEvent(
-        game,
-        AppScreenIconEnum.EMOJI_EVENTS,
-        foundAchievement.title,
-        foundAchievement.description
-      ));
+      player.sendMessage(
+        new SnackbarSendToPlayerWsEvent(
+          game,
+          AppScreenIconEnum.EMOJI_EVENTS,
+          foundAchievement.title,
+          foundAchievement.description,
+        ),
+      );
     }
   }
-}
+}

package/src/modules/base-achievements/index.ts

@@ -1 +1 @@
-export { BaseAchievementsModule } from './base-achievements.module';
+export { BaseAchievementsModule } from './base-achievements.module';

package/src/modules/event-bus/events-bus.app.subscribe.service.ts

@@ -2,20 +2,19 @@ import { Injectable } from '@nestjs/common';
 import { BaseAppEvent } from 'jp.ms.common.engine';
 import { Subject } from 'rxjs';
 
-
 @Injectable()
 export class EventsBusAppSubscribeService {
-    private readonly appEventSubject: Subject<BaseAppEvent>;
+  private readonly appEventSubject: Subject<BaseAppEvent>;
 
-    constructor() {
-        this.appEventSubject = new Subject<BaseAppEvent>();
-    }
+  constructor() {
+    this.appEventSubject = new Subject<BaseAppEvent>();
+  }
 
-    pushNewEvent(event: BaseAppEvent) {
-        this.appEventSubject.next(event);
-    }
+  pushNewEvent(event: BaseAppEvent) {
+    this.appEventSubject.next(event);
+  }
 
-    subscribe(onHandleAppEvent: (event: BaseAppEvent) => void) {
-        this.appEventSubject.subscribe(onHandleAppEvent);
-    }
-}
+  subscribe(onHandleAppEvent: (event: BaseAppEvent) => void) {
+    this.appEventSubject.subscribe(onHandleAppEvent);
+  }
+}

package/src/modules/event-bus/events-bus.main-tables.subscribe.service.ts

@@ -1,34 +1,34 @@
-import { Injectable } from "@nestjs/common";
-import { GamePlayer, RoomUpdateStateEvent } from "jp.ms.common.engine";
+import { Injectable } from '@nestjs/common';
+import { GamePlayer, RoomUpdateStateEvent } from 'jp.ms.common.engine';
 import { Subject } from 'rxjs';
 
 @Injectable()
 export class EventsBusMainTablesSubscribeService {
-    private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
-    private readonly tablesSubscribers: Map<string, GamePlayer>;
+  private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
+  private readonly tablesSubscribers: Map<string, GamePlayer>;
 
-    constructor() {
-        this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
-        this.tablesSubscribers = new Map();
-    }
+  constructor() {
+    this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
+    this.tablesSubscribers = new Map();
+  }
 
-    getTablesSubscribers() {
-        return Array.from(this.tablesSubscribers.values());
-    }
+  getTablesSubscribers() {
+    return Array.from(this.tablesSubscribers.values());
+  }
 
-    addTablesSubscriber(player: GamePlayer) {
-        this.tablesSubscribers.set(player.id, player);
-    }
+  addTablesSubscriber(player: GamePlayer) {
+    this.tablesSubscribers.set(player.id, player);
+  }
 
-    removeTablesSubbcriber(player: GamePlayer) {
-        this.tablesSubscribers.delete(player.id);
-    }
+  removeTablesSubbcriber(player: GamePlayer) {
+    this.tablesSubscribers.delete(player.id);
+  }
 
-    pushNewRoomState(event: RoomUpdateStateEvent) {
-        this.roomStatesSubject.next(event);
-    }
+  pushNewRoomState(event: RoomUpdateStateEvent) {
+    this.roomStatesSubject.next(event);
+  }
 
-    subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
-        this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
-    }
-}
+  subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
+    this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
+  }
+}

package/src/modules/event-bus/events-bus.many-tables-tournament.subscribe.service.ts

@@ -1,6 +1,6 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
 
 import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
 
 @Injectable()
-export class EventsBusManyTablesTournamentSubscribeService extends EventsBusTournamentSubscribeService {}
+export class EventsBusManyTablesTournamentSubscribeService extends EventsBusTournamentSubscribeService {}

package/src/modules/event-bus/events-bus.module.ts

@@ -18,6 +18,6 @@ import { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service
     EventsBusOneTableTournamentSubscribeService,
     EventsBusManyTablesTournamentSubscribeService,
     EventsBusAppSubscribeService,
-  ]
+  ],
 })
-export class EventsBusModule { }
+export class EventsBusModule {}

package/src/modules/event-bus/events-bus.one-table-tournament.subscribe.service.ts

@@ -1,6 +1,6 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
 
 import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
 
 @Injectable()
-export class EventsBusOneTableTournamentSubscribeService extends EventsBusTournamentSubscribeService {}
+export class EventsBusOneTableTournamentSubscribeService extends EventsBusTournamentSubscribeService {}

package/src/modules/event-bus/events-bus.tournament.subscribe.service.ts

@@ -1,19 +1,18 @@
 import { RoomUpdateStateEvent } from 'jp.ms.common.engine';
 import { Subject } from 'rxjs';
 
-
 export abstract class EventsBusTournamentSubscribeService {
-    private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
+  private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
 
-    constructor() {
-        this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
-    }
+  constructor() {
+    this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
+  }
 
-    pushNewRoomState(event: RoomUpdateStateEvent) {
-        this.roomStatesSubject.next(event);
-    }
+  pushNewRoomState(event: RoomUpdateStateEvent) {
+    this.roomStatesSubject.next(event);
+  }
 
-    subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
-        this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
-    }
-}
+  subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
+    this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
+  }
+}

package/src/modules/event-bus/index.ts

@@ -2,4 +2,4 @@ export { EventsBusModule } from './events-bus.module';
 export { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
 export { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
 export { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
-export { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';
+export { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';

package/src/modules/events/events.gateway.ts

@@ -1,68 +1,70 @@
 import {
-    WebSocketServer,
-    OnGatewayConnection,
-    OnGatewayDisconnect,
-    WebSocketGateway,
+  WebSocketServer,
+  OnGatewayConnection,
+  OnGatewayDisconnect,
+  WebSocketGateway,
 } from '@nestjs/websockets';
 import { Server, Socket } from 'socket.io';
 import { UsersRepository } from 'jp.db.schemas';
-import { Inject, Injectable } from '@nestjs/common';
+import { Inject } from '@nestjs/common';
 
 import { PlayersManagerService } from '../players-manager/players-manager.service';
 
 import { EVENTS_OPTIONS } from './events.constants';
-import { EventsFactoryOptions, EventsModuleOptions } from './events.interfaces';
+import { EventsFactoryOptions } from './events.interfaces';
 
 @WebSocketGateway({ cors: { origin: '*' } })
-export class EventsGateway implements OnGatewayConnection<Socket>, OnGatewayDisconnect<Socket> {
-    @WebSocketServer()
-    server: Server;
+export class EventsGateway
+  implements OnGatewayConnection<Socket>, OnGatewayDisconnect<Socket>
+{
+  @WebSocketServer()
+  server: Server;
 
-    constructor (
-        private readonly playersManager: PlayersManagerService,
-        private readonly usersRepository: UsersRepository,
-        @Inject(EVENTS_OPTIONS) private readonly options: EventsFactoryOptions,
-    ) {
-    }
+  constructor(
+    private readonly playersManager: PlayersManagerService,
+    private readonly usersRepository: UsersRepository,
+    @Inject(EVENTS_OPTIONS) private readonly options: EventsFactoryOptions,
+  ) {}
 
-    async handleConnection (client: Socket) {
-        const playerId = client.handshake.auth.token as string | undefined;
+  async handleConnection(client: Socket) {
+    const playerId = client.handshake.auth.token as string | undefined;
 
-        const player = this.playersManager.getPlayerById(playerId ?? '');
-        if (player) {
-            player.connections.addConnection(client);
-        } else {
-            const user = await this.usersRepository.findById(playerId ?? '');
-            if (user) {
-                const player = this.options.createPlayer({
-                    id: user.userId,
-                    fullName: user.fullName,
-                    avatarUrl: user.avatarUrl,
-                    balance: user.balance,
-                    experience: user.experience,
-                    level: user.level,
-                    language: user.normalizedLang,
-                });
-                this.playersManager.addPlayer(player);
-                player.connections.addConnection(client);
-            }
-        }
+    const player = this.playersManager.getPlayerById(playerId ?? '');
+    if (player) {
+      player.connections.addConnection(client);
+    } else {
+      const user = await this.usersRepository.findById(playerId ?? '');
+      if (user) {
+        const player = this.options.createPlayer({
+          id: user.userId,
+          fullName: user.fullName,
+          avatarUrl: user.avatarUrl,
+          balance: user.balance,
+          experience: user.experience,
+          level: user.level,
+          language: user.normalizedLang,
+        });
+        this.playersManager.addPlayer(player);
+        player.connections.addConnection(client);
+      }
     }
+  }
 
-    handleDisconnect (client: Socket): void {
-        const playerId = client.handshake.auth.token as string | undefined;
-        const connectedPlayer = this.playersManager.getPlayerById(playerId ?? '');
+  handleDisconnect(client: Socket): void {
+    const playerId = client.handshake.auth.token as string | undefined;
+    const connectedPlayer = this.playersManager.getPlayerById(playerId ?? '');
 
-        if (connectedPlayer) {
-            connectedPlayer.disconnect();
+    if (connectedPlayer) {
+      connectedPlayer.disconnect();
 
-            if (!connectedPlayer.isPlayer() &&
-                !connectedPlayer.isTableQueuer() &&
-                !connectedPlayer.isRoomQueuer() &&
-                !connectedPlayer.hasOpenConnection()
-            ) {
-                this.playersManager.removePlayer(playerId ?? '');
-            }
-        }
+      if (
+        !connectedPlayer.isPlayer() &&
+        !connectedPlayer.isTableQueuer() &&
+        !connectedPlayer.isRoomQueuer() &&
+        !connectedPlayer.hasOpenConnection()
+      ) {
+        this.playersManager.removePlayer(playerId ?? '');
+      }
     }
+  }
 }

package/src/modules/events/events.interfaces.ts

@@ -4,13 +4,14 @@ import { Type } from '@nestjs/common/interfaces/type.interface';
 import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
 import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
 
-
 export interface EventsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
 }
 
 export interface EventsFactoryOptions {
-    createPlayer: (config: IGamePlayerConfig) => GamePlayer;
+  createPlayer: (config: IGamePlayerConfig) => GamePlayer;
 }