trucoshi 0.2.14 → 0.2.16

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./lib";
-export * from "./server";
 export * from "./types";

package/dist/index.js

@@ -15,5 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib"), exports);
-__exportStar(require("./server"), exports);
 __exportStar(require("./types"), exports);

package/dist/lib/classes/GameLoop.d.ts

@@ -4,7 +4,7 @@ import { IPlayInstance } from "./Play";
 import { IPlayer } from "./Player";
 import { ITeam } from "./Team";
 export type IWinnerCallback = (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>;
-export type ITurnCallback = (play: IPlayInstance) => Promise<void>;
+export type ITurnCallback = (play: IPlayInstance, newHandJustStarted: boolean) => Promise<void>;
 export type ITrucoCallback = (play: IPlayInstance) => Promise<void>;
 export interface IGameLoop {
     _onTruco: ITrucoCallback;
@@ -12,7 +12,7 @@ export interface IGameLoop {
     _onWinner: IWinnerCallback;
     currentPlayer: IPlayer | null;
     currentHand: IHand | null;
-    previousHand: IHand | null;
+    lastCheckedHand: number | null;
     teams: Array<ITeam>;
     winner: ITeam | null;
     onTurn: (callback: ITurnCallback) => IGameLoop;

package/dist/lib/classes/GameLoop.js

@@ -20,7 +20,7 @@ const GameLoop = (match) => {
         winner: null,
         currentPlayer: null,
         currentHand: null,
-        previousHand: null,
+        lastCheckedHand: null,
         onTruco: (callback) => {
             gameloop._onTruco = callback;
             return gameloop;
@@ -34,6 +34,7 @@ const GameLoop = (match) => {
             return gameloop;
         },
         begin() {
+            var _a;
             return __awaiter(this, void 0, void 0, function* () {
                 gameloop.teams = match.teams;
                 while (!match.winner) {
@@ -55,12 +56,13 @@ const GameLoop = (match) => {
                     if (play.state === types_1.EHandState.WAITING_PLAY) {
                         play.player.setTurn(true);
                         try {
-                            yield gameloop._onTurn(play);
+                            const newHandJustStarted = gameloop.lastCheckedHand !== ((_a = play.prevHand) === null || _a === void 0 ? void 0 : _a.idx);
+                            gameloop.lastCheckedHand = play.prevHand ? play.prevHand.idx : null;
+                            yield gameloop._onTurn(play, newHandJustStarted);
                         }
                         catch (e) {
                             console.error("GAME LOOP ERROR", e);
                         }
-                        gameloop.previousHand = match.prevHand;
                         play.player.setTurn(false);
                         continue;
                     }

package/dist/lib/classes/Player.d.ts

@@ -14,19 +14,17 @@ export interface IPlayer {
     isOwner: boolean;
     disabled: boolean;
     ready: boolean;
-    connected: boolean;
     setTurn(turn: boolean): void;
     getPublicPlayer(): IPublicPlayer;
     setSession(session: string): void;
     enable(): void;
     disable(): void;
-    setConnected(connected: boolean): void;
     setOwner(owner: boolean): void;
     setReady(ready: boolean): void;
     setHand(hand: Array<ICard>): Array<ICard>;
     useCard(idx: number, card: ICard): ICard | null;
 }
-export type IPublicPlayer = Pick<IPlayer, "id" | "key" | "disabled" | "ready" | "connected" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "session" | "isTurn" | "isOwner"> & {
+export type IPublicPlayer = Pick<IPlayer, "id" | "key" | "disabled" | "ready" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "session" | "isTurn" | "isOwner"> & {
     commands: Array<ECommand>;
 };
 export declare function Player(key: string, id: string, teamIdx: number, isOwner?: boolean): IPlayer;

package/dist/lib/classes/Player.js

@@ -14,7 +14,6 @@ function Player(key, id, teamIdx, isOwner = false) {
         isOwner,
         isTurn: false,
         disabled: false,
-        connected: false,
         ready: false,
         get commands() {
             return Array.from(player._commands.values());
@@ -26,11 +25,10 @@ function Player(key, id, teamIdx, isOwner = false) {
             player.isTurn = turn;
         },
         getPublicPlayer() {
-            const { id, key, commands, connected, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner, } = player;
+            const { id, key, commands, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner, } = player;
             return {
                 id,
                 key,
-                connected,
                 commands,
                 disabled,
                 ready,
@@ -52,9 +50,6 @@ function Player(key, id, teamIdx, isOwner = false) {
         disable() {
             player.disabled = true;
         },
-        setConnected(connected) {
-            player.connected = connected;
-        },
         setReady(ready) {
             player.ready = ready;
         },

package/dist/lib/types.d.ts

@@ -1,26 +1,12 @@
+import { ECommand, EEnvidoCommand } from "../types";
 import { IPlayer } from "./classes/Player";
 import { ITeam } from "./classes/Team";
-export declare enum ESayCommand {
-    QUIERO = "QUIERO",
-    NO_QUIERO = "NO_QUIERO",
-    TRUCO = "TRUCO",
-    MAZO = "MAZO",
-    FLOR = "FLOR",
-    CONTRAFLOR = "CONTRAFLOR"
-}
-export declare enum EEnvidoCommand {
-    ENVIDO = "ENVIDO",
-    ENVIDO_ENVIDO = "ENVIDO_ENVIDO",
-    REAL_ENVIDO = "REAL_ENVIDO",
-    FALTA_ENVIDO = "FALTA_ENVIDO"
-}
 export declare enum EHandState {
     WAITING_PLAY = "WAITING_PLAY",
     WAITING_FOR_TRUCO_ANSWER = "WAITING_FOR_TRUCO_ANSWER",
     WAITING_ENVIDO_ANSWER = "WAITING_ENVIDO_ANSWER",
     FINISHED = "FINISHED"
 }
-export type ECommand = ESayCommand | EEnvidoCommand;
 export declare enum GAME_ERROR {
     MATCH_ALREADY_STARTED = "MATCH_ALREADY_STARTED",
     LOBBY_IS_FULL = "LOBBY_IS_FULL",

package/dist/lib/types.js

@@ -1,22 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GAME_ERROR = exports.EHandState = exports.EEnvidoCommand = exports.ESayCommand = void 0;
-var ESayCommand;
-(function (ESayCommand) {
-    ESayCommand["QUIERO"] = "QUIERO";
-    ESayCommand["NO_QUIERO"] = "NO_QUIERO";
-    ESayCommand["TRUCO"] = "TRUCO";
-    ESayCommand["MAZO"] = "MAZO";
-    ESayCommand["FLOR"] = "FLOR";
-    ESayCommand["CONTRAFLOR"] = "CONTRAFLOR";
-})(ESayCommand = exports.ESayCommand || (exports.ESayCommand = {}));
-var EEnvidoCommand;
-(function (EEnvidoCommand) {
-    EEnvidoCommand["ENVIDO"] = "ENVIDO";
-    EEnvidoCommand["ENVIDO_ENVIDO"] = "ENVIDO_ENVIDO";
-    EEnvidoCommand["REAL_ENVIDO"] = "REAL_ENVIDO";
-    EEnvidoCommand["FALTA_ENVIDO"] = "FALTA_ENVIDO";
-})(EEnvidoCommand = exports.EEnvidoCommand || (exports.EEnvidoCommand = {}));
+exports.GAME_ERROR = exports.EHandState = void 0;
 var EHandState;
 (function (EHandState) {
     EHandState["WAITING_PLAY"] = "WAITING_PLAY";

package/dist/types.d.ts

@@ -14,6 +14,7 @@ export interface IPublicMatch {
     rounds: IPlayedCard[][];
 }
 export interface IPublicMatchInfo {
+    ownerId: string;
     matchSessionId: string;
     players: number;
     maxPlayers: number;
@@ -26,7 +27,8 @@ export interface IChatMessage {
         id: string;
         key: string;
     };
-    system: boolean;
+    system?: boolean;
+    command?: boolean;
     content: string;
 }
 export interface IChatRoom {
@@ -34,8 +36,14 @@ export interface IChatRoom {
     messages: Array<IChatMessage>;
     send(user: IChatMessage["user"], message: string): void;
     system(message: string): void;
+    command(team: 0 | 1, command: ECommand): void;
     emit(): void;
 }
+export declare enum EChatSystem {
+    TEAM_0 = 0,
+    TEAM_1 = 1,
+    SYSTEM = "SYSTEM"
+}
 export declare enum EMatchTableState {
     UNREADY = 0,
     READY = 1,
@@ -93,6 +101,7 @@ export type IEnvidoCalculator = {
 export declare enum EClientEvent {
     PING = "PING",
     SAY = "SAY",
+    LEAVE_MATCH = "LEAVE_MATCH",
     CREATE_MATCH = "CREATE_MATCH",
     LIST_MATCHES = "LIST_MATCHES",
     JOIN_MATCH = "JOIN_MATCH",
@@ -116,6 +125,7 @@ export interface ServerToClientEvents {
 export interface ClientToServerEvents {
     [EClientEvent.PING]: (msg: string) => void;
     [EClientEvent.CHAT]: (matchId: string, msg: string, callback: () => void) => void;
+    [EClientEvent.LEAVE_MATCH]: (matchId: string) => void;
     [EClientEvent.CREATE_MATCH]: (callback: IEventCallback<{
         match?: IPublicMatch;
     }>) => void;
@@ -169,5 +179,4 @@ export interface TMap<K, V> extends Map<K, V> {
 export declare class TMap<K, V> extends Map<K, V> {
     findAll(finder: (value: V) => boolean): V[];
     getOrThrow(key?: K): NonNullable<V>;
-    update(key: K, value: Partial<V>): void;
 }

package/dist/types.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TMap = exports.ETrucoshiMatchState = exports.EServerEvent = exports.EClientEvent = exports.GAME_ERROR = exports.EHandState = exports.EEnvidoCommand = exports.ESayCommand = exports.EMatchTableState = void 0;
+exports.TMap = exports.ETrucoshiMatchState = exports.EServerEvent = exports.EClientEvent = exports.GAME_ERROR = exports.EHandState = exports.EEnvidoCommand = exports.ESayCommand = exports.EMatchTableState = exports.EChatSystem = void 0;
+var EChatSystem;
+(function (EChatSystem) {
+    EChatSystem[EChatSystem["TEAM_0"] = 0] = "TEAM_0";
+    EChatSystem[EChatSystem["TEAM_1"] = 1] = "TEAM_1";
+    EChatSystem["SYSTEM"] = "SYSTEM";
+})(EChatSystem = exports.EChatSystem || (exports.EChatSystem = {}));
 var EMatchTableState;
 (function (EMatchTableState) {
     EMatchTableState[EMatchTableState["UNREADY"] = 0] = "UNREADY";
@@ -43,6 +49,7 @@ var EClientEvent;
 (function (EClientEvent) {
     EClientEvent["PING"] = "PING";
     EClientEvent["SAY"] = "SAY";
+    EClientEvent["LEAVE_MATCH"] = "LEAVE_MATCH";
     EClientEvent["CREATE_MATCH"] = "CREATE_MATCH";
     EClientEvent["LIST_MATCHES"] = "LIST_MATCHES";
     EClientEvent["JOIN_MATCH"] = "JOIN_MATCH";
@@ -95,12 +102,5 @@ class TMap extends Map {
         }
         return result;
     }
-    update(key, value) {
-        const current = this.get(key);
-        if (!current) {
-            throw new Error(`update(${key}) not found`);
-        }
-        this.set(key, Object.assign(Object.assign({}, current), value));
-    }
 }
 exports.TMap = TMap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "scripts": {
@@ -28,7 +28,6 @@
     "dist/index.d.ts",
     "dist/types.js",
     "dist/types.d.ts",
-    "dist/server/**/*",
     "dist/lib/**/*"
   ],
   "dependencies": {

package/dist/server/classes/Chat.d.ts

@@ -1,7 +0,0 @@
-import { IChatRoom, TMap } from "../../types";
-import { TrucoshiServer } from "./SocketServer";
-export interface IChat {
-    rooms: TMap<string, IChatRoom>;
-    create(id: string): void;
-}
-export declare const Chat: (io: TrucoshiServer) => IChat;

package/dist/server/classes/Chat.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Chat = void 0;
-const types_1 = require("../../types");
-const SYSTEM_ID = "system";
-const ChatMessage = (user, message, system = false) => {
-    return {
-        date: Date.now() / 1000,
-        user,
-        system,
-        content: message,
-    };
-};
-const ChatRoom = (io, id) => {
-    const room = {
-        id,
-        messages: [],
-        send(user, message) {
-            room.messages.push(ChatMessage(user, message));
-            room.emit();
-        },
-        system(message) {
-            room.messages.push(ChatMessage({ id: SYSTEM_ID, key: SYSTEM_ID }, message, true));
-            room.emit();
-        },
-        emit() {
-            io.sockets.adapter
-                .fetchSockets({
-                rooms: new Set([room.id]),
-            })
-                .then((sockets) => {
-                for (const playerSocket of sockets) {
-                    playerSocket.emit(types_1.EServerEvent.UPDATE_CHAT, { id: room.id, messages: room.messages });
-                }
-            });
-        },
-    };
-    return room;
-};
-const Chat = (io) => {
-    const chat = {
-        rooms: new types_1.TMap(),
-        create(id) {
-            const room = ChatRoom(io, id);
-            const exists = chat.rooms.get(id);
-            if (exists) {
-                return;
-            }
-            chat.rooms.set(id, room);
-        },
-    };
-    const adapter = io.of("/").adapter;
-    adapter.on("join-room", (room, socketId) => {
-        var _a;
-        const userSocket = io.sockets.sockets.get(socketId);
-        if (!userSocket || !userSocket.data.user) {
-            return;
-        }
-        const { id, key } = userSocket.data.user;
-        (_a = chat.rooms.get(room)) === null || _a === void 0 ? void 0 : _a.system(`${id} entro a la sala`);
-        userSocket.on(types_1.EClientEvent.CHAT, (matchId, message, callback) => {
-            if (matchId !== room || !userSocket.data.user) {
-                return;
-            }
-            const chatroom = chat.rooms.get(matchId);
-            if (chatroom) {
-                chatroom.send({ id, key }, message);
-            }
-            callback();
-        });
-    });
-    adapter.on("leave-room", (room, socketId) => {
-        var _a;
-        const userSocket = io.sockets.sockets.get(socketId);
-        if (!userSocket || !userSocket.data.user) {
-            return;
-        }
-        const { id } = userSocket.data.user;
-        (_a = chat.rooms.get(room)) === null || _a === void 0 ? void 0 : _a.system(`${id} salio de la sala`);
-    });
-    return chat;
-};
-exports.Chat = Chat;

package/dist/server/classes/MatchTable.d.ts

@@ -1,15 +0,0 @@
-import { IHand, ILobby, IPlayedCard, IPlayer } from "../../lib";
-import { EMatchTableState, IMatchPreviousHand, IPublicMatch, IPublicMatchInfo } from "../../types";
-export interface IMatchTable {
-    ownerSession: string;
-    matchSessionId: string;
-    lobby: ILobby;
-    state(): EMatchTableState;
-    isSessionPlaying(session: string): IPlayer | null;
-    getPreviousHand(hand: IHand): IMatchPreviousHand;
-    getHandRounds(hand: IHand): IPlayedCard[][];
-    getPublicMatch(session?: string): IPublicMatch;
-    getPublicMatchInfo(): IPublicMatchInfo;
-    waitPlayerReconnection(player: IPlayer, callback: (onReconnect: () => void, onAbandon: () => void) => void, update: () => void): Promise<void>;
-}
-export declare function MatchTable(matchSessionId: string, ownerSession: string, teamSize?: 1 | 2 | 3): IMatchTable;

package/dist/server/classes/MatchTable.js

@@ -1,112 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatchTable = void 0;
-const lib_1 = require("../../lib");
-const types_1 = require("../../types");
-function MatchTable(matchSessionId, ownerSession, teamSize) {
-    const matchTable = {
-        ownerSession,
-        matchSessionId,
-        lobby: (0, lib_1.Lobby)(teamSize),
-        state() {
-            var _a;
-            matchTable.lobby.calculateReady();
-            if ((_a = matchTable.lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.winner) {
-                return types_1.EMatchTableState.FINISHED;
-            }
-            if (matchTable.lobby.started) {
-                return types_1.EMatchTableState.STARTED;
-            }
-            if (matchTable.lobby.ready) {
-                return types_1.EMatchTableState.READY;
-            }
-            return types_1.EMatchTableState.UNREADY;
-        },
-        isSessionPlaying(session) {
-            const { lobby } = matchTable;
-            const search = lobby.players.find((player) => player && player.session === session);
-            return search || null;
-        },
-        getPublicMatchInfo() {
-            const { matchSessionId, state, lobby: { players, maxPlayers }, } = matchTable;
-            return {
-                matchSessionId,
-                maxPlayers,
-                players: players.length,
-                state: state(),
-            };
-        },
-        waitPlayerReconnection(player, callback, update) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (matchTable.state() !== types_1.EMatchTableState.STARTED) {
-                    player.setReady(false);
-                }
-                update();
-                try {
-                    yield new Promise(callback);
-                }
-                catch (e) {
-                    if (matchTable.state() !== types_1.EMatchTableState.STARTED) {
-                        player.setReady(false);
-                        matchTable.lobby.removePlayer(player.session);
-                    }
-                    else {
-                        player.setReady(true);
-                    }
-                }
-                update();
-            });
-        },
-        getHandRounds(hand) {
-            if (!hand) {
-                return [];
-            }
-            return hand.rounds.map((round) => round.cards) || [];
-        },
-        getPreviousHand(hand) {
-            return {
-                rounds: matchTable.getHandRounds(hand),
-                points: hand.points,
-                matchSessionId: matchTable.matchSessionId,
-            };
-        },
-        getPublicMatch(userSession) {
-            var _a, _b, _c, _d;
-            const { lobby } = matchTable;
-            const winner = ((_a = lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.winner) || null;
-            const rounds = ((_b = lobby.gameLoop) === null || _b === void 0 ? void 0 : _b.currentHand)
-                ? matchTable.getHandRounds((_c = lobby.gameLoop) === null || _c === void 0 ? void 0 : _c.currentHand)
-                : [];
-            const players = lobby.players.filter((player) => Boolean(player));
-            const currentPlayerIdx = players.findIndex((player) => player && player.session === userSession);
-            const me = players[currentPlayerIdx];
-            const cut = players.slice(currentPlayerIdx, players.length);
-            const end = players.slice(0, currentPlayerIdx);
-            const publicPlayers = cut
-                .concat(end)
-                .map((player) => ((player === null || player === void 0 ? void 0 : player.session) === userSession ? player : player.getPublicPlayer()));
-            const teams = ((_d = lobby.gameLoop) === null || _d === void 0 ? void 0 : _d.teams) || lobby.teams;
-            const publicTeams = teams.map((team) => team.getPublicTeam(userSession));
-            return {
-                me,
-                winner,
-                matchSessionId: matchTable.matchSessionId,
-                state: matchTable.state(),
-                teams: publicTeams,
-                players: publicPlayers,
-                rounds
-            };
-        },
-    };
-    return matchTable;
-}
-exports.MatchTable = MatchTable;

package/dist/server/classes/SocketServer.d.ts

@@ -1,34 +0,0 @@
-/// <reference types="node" />
-import { Server as HttpServer } from "http";
-import { Server, Socket } from "socket.io";
-import { IPlayer, IPlayInstance } from "../../lib";
-import { ClientToServerEvents, ECommand, IEventCallback, IPublicMatch, ServerToClientEvents } from "../../types";
-import { IChat } from "./Chat";
-import { IMatchTable } from "./MatchTable";
-import { ITrucoshi } from "./Trucoshi";
-import { IUser } from "./User";
-interface InterServerEvents {
-}
-interface SocketData {
-    user?: IUser;
-}
-export type TrucoshiServer = Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
-export type TrucoshiSocket = Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
-export interface ISocketServer extends ITrucoshi {
-    io: TrucoshiServer;
-    httpServer: HttpServer;
-    chat: IChat;
-    getTableSockets(table: IMatchTable, callback: (playerSocket: TrucoshiSocket, player: IPlayer | null) => Promise<void>): Promise<void>;
-    setOrGetSession(socket: TrucoshiSocket, id: string | null, session: string | null, callback: IEventCallback<{
-        session?: string;
-    }>): Promise<void>;
-    emitWaitingPossibleSay(play: IPlayInstance, table: IMatchTable): Promise<ECommand>;
-    emitWaitingForPlay(play: IPlayInstance, table: IMatchTable): Promise<void>;
-    emitMatchUpdate(table: IMatchTable, skipSocketIds?: Array<string>): Promise<void>;
-    emitPreviousHand(play: IPlayInstance, table: IMatchTable): Promise<void>;
-    emitSocketMatch(socket: TrucoshiSocket, currentMatchId: string | null): IPublicMatch | null;
-    startMatch(matchSessionId: string): Promise<void>;
-    listen: (callback: (io: TrucoshiServer) => void) => void;
-}
-export declare const SocketServer: (trucoshi: ITrucoshi, port: number, origin?: string | Array<string>) => ISocketServer;
-export {};

package/dist/server/classes/SocketServer.js

@@ -1,304 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocketServer = void 0;
-const crypto_1 = require("crypto");
-const http_1 = require("http");
-const socket_io_1 = require("socket.io");
-const types_1 = require("../../types");
-const constants_1 = require("../constants");
-const Chat_1 = require("./Chat");
-const User_1 = require("./User");
-const SocketServer = (trucoshi, port, origin) => {
-    const httpServer = (0, http_1.createServer)();
-    const io = new socket_io_1.Server(httpServer, {
-        cors: {
-            origin,
-            methods: ["GET", "POST"],
-        },
-    });
-    const server = {
-        io,
-        httpServer,
-        turns: trucoshi.turns,
-        tables: trucoshi.tables,
-        users: trucoshi.users,
-        chat: (0, Chat_1.Chat)(io),
-        listen(callback) {
-            httpServer.listen(port, undefined, undefined, () => callback(server.io));
-        },
-        setOrGetSession(socket, id, session, callback = () => { }) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (session) {
-                    const user = server.users.get(session);
-                    if (user) {
-                        const newId = id || user.id || "Satoshi";
-                        user.connect();
-                        user.setId(newId);
-                        socket.data.user = user;
-                        return callback({ success: true, session });
-                    }
-                }
-                const newSession = (0, crypto_1.randomUUID)();
-                const userKey = (0, crypto_1.randomUUID)();
-                const newId = id || "Satoshi";
-                const newUser = (0, User_1.User)(userKey, newId, newSession);
-                socket.data.user = newUser;
-                server.users.set(newSession, newUser);
-                callback({ success: false, session: newSession });
-            });
-        },
-        getTableSockets(table, callback) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    const sockets = yield server.io.sockets.adapter.fetchSockets({
-                        rooms: new Set([table.matchSessionId]),
-                    });
-                    for (const playerSocket of sockets) {
-                        if (!((_a = playerSocket.data.user) === null || _a === void 0 ? void 0 : _a.session)) {
-                            continue;
-                        }
-                        const player = table.isSessionPlaying(playerSocket.data.user.session);
-                        yield callback(playerSocket, player);
-                    }
-                    resolve();
-                }));
-            });
-        },
-        emitMatchUpdate(table, skipSocketIds = []) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield server.getTableSockets(table, (playerSocket) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    if (skipSocketIds.includes(playerSocket.id)) {
-                        return;
-                    }
-                    playerSocket.emit(types_1.EServerEvent.UPDATE_MATCH, table.getPublicMatch((_a = playerSocket.data.user) === null || _a === void 0 ? void 0 : _a.session));
-                }));
-            });
-        },
-        emitWaitingPossibleSay(play, table) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let someoneSaidSomething = false;
-                return new Promise((resolve, reject) => {
-                    return server.getTableSockets(table, (playerSocket, player) => __awaiter(this, void 0, void 0, function* () {
-                        if (!player) {
-                            return;
-                        }
-                        playerSocket.emit(types_1.EServerEvent.WAITING_POSSIBLE_SAY, table.getPublicMatch(player.session), (data) => {
-                            var _a;
-                            if (!data) {
-                                return;
-                            }
-                            if (someoneSaidSomething) {
-                                return;
-                            }
-                            const { command } = data;
-                            try {
-                                if (command) {
-                                    const saidCommand = play.say(command, player);
-                                    if (saidCommand) {
-                                        someoneSaidSomething = true;
-                                        (_a = server.chat.rooms
-                                            .get(table.matchSessionId)) === null || _a === void 0 ? void 0 : _a.send({ id: player.id, key: player.key }, saidCommand);
-                                        return resolve(saidCommand);
-                                    }
-                                }
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
-                        });
-                    }));
-                });
-            });
-        },
-        emitWaitingForPlay(play, table) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return new Promise((resolve, reject) => {
-                    server
-                        .emitWaitingPossibleSay(play, table)
-                        .then(() => {
-                        resolve();
-                    })
-                        .catch(console.error);
-                    return server.getTableSockets(table, (playerSocket, player) => __awaiter(this, void 0, void 0, function* () {
-                        var _a;
-                        if (!player) {
-                            return;
-                        }
-                        if (player.session === ((_a = play.player) === null || _a === void 0 ? void 0 : _a.session)) {
-                            playerSocket.emit(types_1.EServerEvent.WAITING_PLAY, table.getPublicMatch(player.session), (data) => {
-                                if (!data) {
-                                    return reject(new Error(types_1.EServerEvent.WAITING_PLAY + " callback returned empty"));
-                                }
-                                const { cardIdx, card } = data;
-                                if (cardIdx !== undefined && card) {
-                                    const playedCard = play.use(cardIdx, card);
-                                    if (playedCard) {
-                                        return resolve();
-                                    }
-                                    return reject(new Error("Invalid Card"));
-                                }
-                                return reject(new Error("Invalid Callback Response"));
-                            });
-                        }
-                    }));
-                });
-            });
-        },
-        emitPreviousHand(play, table) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const promises = [];
-                        yield server.getTableSockets(table, (playerSocket, player) => __awaiter(this, void 0, void 0, function* () {
-                            promises.push(new Promise((resolvePlayer, rejectPlayer) => {
-                                if (!player || !play.prevHand) {
-                                    return rejectPlayer();
-                                }
-                                playerSocket.emit(types_1.EServerEvent.PREVIOUS_HAND, table.getPreviousHand(play.prevHand), resolvePlayer);
-                                setTimeout(() => {
-                                    rejectPlayer();
-                                }, constants_1.PREVIOUS_HAND_ACK_TIMEOUT);
-                            }));
-                        }));
-                        yield Promise.allSettled(promises);
-                        resolve();
-                    }
-                    catch (e) {
-                        reject(e);
-                    }
-                }));
-            });
-        },
-        startMatch(matchSessionId) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const table = server.tables.getOrThrow(matchSessionId);
-                if (table && !table.lobby.gameLoop) {
-                    table.lobby
-                        .startMatch()
-                        .onTurn((play) => {
-                        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                            var _a, _b;
-                            const currentTurn = server.turns.get(table.matchSessionId);
-                            const emitPreviousHand = currentTurn
-                                ? currentTurn.previousHandIdx !== ((_a = play.prevHand) === null || _a === void 0 ? void 0 : _a.idx)
-                                : false;
-                            server.turns.set(table.matchSessionId, {
-                                play,
-                                resolve,
-                                previousHandIdx: play.prevHand ? play.prevHand.idx : null,
-                            });
-                            try {
-                                const session = (_b = play.player) === null || _b === void 0 ? void 0 : _b.session;
-                                if (!session || !play) {
-                                    throw new Error("Unexpected Error");
-                                }
-                                server.users.getOrThrow(session);
-                                if (emitPreviousHand) {
-                                    yield server.emitPreviousHand(play, table);
-                                }
-                                yield server.emitWaitingForPlay(play, table);
-                                return resolve();
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
-                        }));
-                    })
-                        .onTruco((play) => {
-                        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                            server.turns.update(table.matchSessionId, {
-                                play,
-                                resolve,
-                            });
-                            try {
-                                yield server.emitWaitingPossibleSay(play, table);
-                                return resolve();
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
-                        }));
-                    })
-                        .onWinner(() => __awaiter(this, void 0, void 0, function* () {
-                        yield server.emitMatchUpdate(table);
-                    }))
-                        .begin();
-                    server.tables.set(matchSessionId, table);
-                    return;
-                }
-            });
-        },
-        emitSocketMatch(socket, matchId) {
-            var _a;
-            if (!matchId || !((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session)) {
-                return null;
-            }
-            const currentTable = server.tables.get(matchId);
-            if (currentTable) {
-                socket.join(currentTable.matchSessionId);
-                const { play, resolve } = server.turns.get(currentTable.matchSessionId) || {};
-                if (play && play.player && currentTable.isSessionPlaying(socket.data.user.session)) {
-                    if (play.state === types_1.EHandState.WAITING_PLAY &&
-                        socket.data.user.session === play.player.session) {
-                        server.emitWaitingForPlay(play, currentTable).then(resolve).catch(console.error);
-                    }
-                    else {
-                        server.emitWaitingPossibleSay(play, currentTable).then(resolve).catch(console.error);
-                    }
-                }
-                else {
-                    socket.emit(types_1.EServerEvent.UPDATE_MATCH, currentTable.getPublicMatch(socket.data.user.session));
-                }
-                return currentTable.getPublicMatch(socket.data.user.session);
-            }
-            return null;
-        },
-    };
-    const getPossiblePlayingMatch = (room, socketId) => {
-        const socket = server.io.sockets.sockets.get(socketId);
-        if (!socket || !socket.data.user) {
-            return null;
-        }
-        const table = server.tables.get(room);
-        if (table) {
-            const player = table.isSessionPlaying(socket.data.user.session);
-            if (player) {
-                return { table, player, user: socket.data.user };
-            }
-        }
-        return null;
-    };
-    io.of("/").adapter.on("leave-room", (room, socketId) => {
-        const playingMatch = getPossiblePlayingMatch(room, socketId);
-        if (!playingMatch) {
-            return;
-        }
-        const { player, table, user } = playingMatch;
-        table.waitPlayerReconnection(player, (reconnect, abandon) => {
-            user.waitReconnection(table.matchSessionId, reconnect, abandon);
-        }, () => {
-            server.emitMatchUpdate(table, []);
-        });
-    });
-    io.of("/").adapter.on("join-room", (room, socketId) => {
-        const playingMatch = getPossiblePlayingMatch(room, socketId);
-        if (!playingMatch) {
-            return;
-        }
-        const { table, user } = playingMatch;
-        user.reconnect(table.matchSessionId);
-    });
-    return server;
-};
-exports.SocketServer = SocketServer;

package/dist/server/classes/Trucoshi.d.ts

@@ -1,23 +0,0 @@
-import { IPlayInstance } from "../../lib";
-import { EMatchTableState, IPublicMatchInfo, TMap } from "../../types";
-import { IMatchTable } from "./MatchTable";
-import { IUser } from "./User";
-export interface ITrucoshi {
-    users: TMap<string, IUser>;
-    tables: MatchTableMap;
-    turns: TMap<string, ITrucoshiTurn>;
-}
-interface ITrucoshiTurn {
-    previousHandIdx: number | null;
-    play: IPlayInstance;
-    resolve(): void;
-}
-interface MatchTableMap extends TMap<string, IMatchTable> {
-    getAll(filters: {
-        state?: Array<EMatchTableState>;
-    }): Array<IPublicMatchInfo>;
-}
-declare class MatchTableMap extends TMap<string, IMatchTable> {
-}
-export declare const Trucoshi: () => ITrucoshi;
-export {};

package/dist/server/classes/Trucoshi.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Trucoshi = void 0;
-const types_1 = require("../../types");
-class MatchTableMap extends types_1.TMap {
-    getAll(filters = {}) {
-        let results = [];
-        for (let value of this.values()) {
-            if (!filters.state || !filters.state.length || filters.state.includes(value.state())) {
-                results.push(value.getPublicMatchInfo());
-            }
-        }
-        return results;
-    }
-}
-const Trucoshi = () => {
-    const users = new types_1.TMap(); // sessionId, user
-    const tables = new MatchTableMap(); // sessionId, table
-    const turns = new types_1.TMap(); // sessionId, play instance, play promise resolve and type
-    const trucoshi = {
-        users,
-        tables,
-        turns,
-    };
-    return trucoshi;
-};
-exports.Trucoshi = Trucoshi;

package/dist/server/classes/User.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="node" />
-export interface IUser {
-    key: string;
-    id: string;
-    session: string;
-    online: boolean;
-    ownedMatchId: string | null;
-    waitingTimeouts: Map<string, NodeJS.Timeout | null>;
-    waitingPromises: Map<string, () => void>;
-    waitReconnection(room: string, reconnect: () => void, abandon: () => void): void;
-    setOwnedMatch(id: string): void;
-    connect(): void;
-    disconnect(): void;
-    reconnect(room: string): void;
-    setId(id: string): void;
-}
-export declare function User(key: string, id: string, session: string): IUser;

package/dist/server/classes/User.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.User = void 0;
-const PLAYER_ABANDON_TIMEOUT = 10000;
-function User(key, id, session) {
-    const user = {
-        id,
-        key,
-        session,
-        online: true,
-        ownedMatchId: null,
-        waitingTimeouts: new Map(),
-        waitingPromises: new Map(),
-        waitReconnection(room, reconnect, abandon) {
-            user.waitingTimeouts.set(room, setTimeout(() => {
-                abandon();
-                user.waitingPromises.delete(room);
-            }, PLAYER_ABANDON_TIMEOUT));
-            user.waitingPromises.set(room, reconnect);
-        },
-        reconnect(room) {
-            const promise = user.waitingPromises.get(room);
-            if (promise) {
-                promise();
-                user.waitingPromises.delete(room);
-            }
-            const timeout = user.waitingTimeouts.get(room);
-            if (timeout) {
-                clearTimeout(timeout);
-                user.waitingTimeouts.delete(room);
-            }
-        },
-        setOwnedMatch(id) {
-            user.ownedMatchId = id;
-        },
-        connect() {
-            user.online = true;
-        },
-        disconnect() {
-            user.online = false;
-        },
-        setId(id) {
-            user.id = id;
-        },
-    };
-    return user;
-}
-exports.User = User;

package/dist/server/classes/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./Chat";
-export * from "./MatchTable";
-export * from "./SocketServer";
-export * from "./Trucoshi";
-export * from "./User";

package/dist/server/classes/index.js

@@ -1,21 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = 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];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Chat"), exports);
-__exportStar(require("./MatchTable"), exports);
-__exportStar(require("./SocketServer"), exports);
-__exportStar(require("./Trucoshi"), exports);
-__exportStar(require("./User"), exports);

package/dist/server/constants.d.ts

@@ -1 +0,0 @@
-export declare const PREVIOUS_HAND_ACK_TIMEOUT = 5000;

package/dist/server/constants.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PREVIOUS_HAND_ACK_TIMEOUT = void 0;
-exports.PREVIOUS_HAND_ACK_TIMEOUT = 5000;

package/dist/server/index.d.ts

@@ -1 +0,0 @@
-export * from './classes';

package/dist/server/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = 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];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./classes"), exports);

package/dist/server/middlewares/trucoshiEvents.d.ts

@@ -1,3 +0,0 @@
-import { ExtendedError } from "socket.io/dist/namespace";
-import { ISocketServer, TrucoshiSocket } from "../classes";
-export declare const trucoshiEvents: (server: ISocketServer) => (socket: TrucoshiSocket, next: (err?: ExtendedError) => void) => void;

package/dist/server/middlewares/trucoshiEvents.js

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trucoshiEvents = void 0;
-const crypto_1 = require("crypto");
-const types_1 = require("../../types");
-const classes_1 = require("../classes");
-const trucoshiEvents = (server) => (socket, next) => {
-    socket.on("disconnect", (_reason) => {
-        var _a;
-        try {
-            const user = server.users.getOrThrow((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session);
-            if (user) {
-                user.disconnect();
-            }
-        }
-        catch (e) {
-            // noop
-        }
-    });
-    socket.on(types_1.EClientEvent.PING, (msg) => {
-        socket.emit(types_1.EServerEvent.PONG, msg);
-    });
-    /**
-     * Create Match
-     */
-    socket.on(types_1.EClientEvent.CREATE_MATCH, (callback) => {
-        try {
-            if (!socket.data.user) {
-                throw new Error("Session not found");
-            }
-            const user = server.users.getOrThrow(socket.data.user.session);
-            const existingTable = user.ownedMatchId && server.tables.get(user.ownedMatchId);
-            if (existingTable) {
-                return callback({
-                    success: false,
-                    match: existingTable.getPublicMatch(socket.data.user.session),
-                });
-            }
-            const matchId = (0, crypto_1.randomUUID)();
-            const table = (0, classes_1.MatchTable)(matchId, socket.data.user.session);
-            user.ownedMatchId = matchId;
-            table.lobby.addPlayer(user.key, user.id, socket.data.user.session, 0, true);
-            server.chat.create(matchId);
-            socket.join(matchId);
-            server.tables.set(matchId, table);
-            return callback({ success: true, match: table.getPublicMatch(user.id) });
-        }
-        catch (e) {
-            return callback({ success: false });
-        }
-    });
-    /**
-     * Start Match
-     */
-    socket.on(types_1.EClientEvent.START_MATCH, (callback) => {
-        var _a;
-        try {
-            const user = server.users.getOrThrow((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session);
-            const matchId = user.ownedMatchId;
-            if (matchId) {
-                server.startMatch(matchId);
-                return callback({ success: true, matchSessionId: matchId });
-            }
-        }
-        catch (e) {
-            callback({ success: false });
-        }
-        callback({ success: false });
-    });
-    /**
-     * Join Match
-     */
-    socket.on(types_1.EClientEvent.JOIN_MATCH, (matchSessionId, teamIdx, callback) => {
-        var _a, _b;
-        try {
-            const user = server.users.getOrThrow((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session);
-            const table = server.tables.get(matchSessionId);
-            if (table) {
-                table.lobby.addPlayer(user.key, user.id, user.session, teamIdx, user.ownedMatchId === matchSessionId);
-                socket.join(table.matchSessionId);
-                server.emitMatchUpdate(table, []);
-                return callback({ success: true, match: table.getPublicMatch((_b = socket.data.user) === null || _b === void 0 ? void 0 : _b.session) });
-            }
-            callback({ success: false });
-        }
-        catch (e) {
-            callback({ success: false });
-        }
-    });
-    /**
-     * Get public matches
-     */
-    socket.on(types_1.EClientEvent.LIST_MATCHES, (filters = {}, callback) => {
-        const publicMatches = server.tables.getAll(filters);
-        callback({ success: true, matches: publicMatches });
-    });
-    /**
-     * Set Session
-     */
-    socket.on(types_1.EClientEvent.SET_SESSION, (id, session, callback = () => { }) => {
-        server.setOrGetSession(socket, id, session, ({ success, session }) => {
-            if (session && success) {
-                const activeMatches = server.tables
-                    .findAll((table) => Boolean(table.isSessionPlaying(session)))
-                    .map((match) => match.getPublicMatchInfo());
-                return callback({ success, session, activeMatches });
-            }
-            callback({ success, session, activeMatches: [] });
-        });
-    });
-    /**
-     * Fetch match with session
-     */
-    socket.on(types_1.EClientEvent.FETCH_MATCH, (session, matchId, callback) => {
-        return server.setOrGetSession(socket, null, session, ({ success }) => {
-            var _a;
-            if (!success) {
-                return callback({ success: false, match: null });
-            }
-            (_a = server.chat.rooms.get(matchId)) === null || _a === void 0 ? void 0 : _a.emit();
-            const match = server.emitSocketMatch(socket, matchId);
-            callback({ success: Boolean(match), match });
-        });
-    });
-    /**
-     * Set Player Ready
-     */
-    socket.on(types_1.EClientEvent.SET_PLAYER_READY, (matchSessionId, ready, callback) => {
-        var _a;
-        try {
-            if (!socket.data.user) {
-                throw new Error("Session not found");
-            }
-            const table = server.tables.getOrThrow(matchSessionId);
-            const player = table.lobby.players.find((player) => { var _a; return player && player.session === ((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session); });
-            if (player) {
-                player.setReady(ready);
-                server.emitMatchUpdate(table, [socket.id]);
-                callback({ success: true, match: table.getPublicMatch((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session) });
-            }
-        }
-        catch (e) {
-            callback({ success: false });
-        }
-    });
-    next();
-};
-exports.trucoshiEvents = trucoshiEvents;