trucoshi 1.0.0 → 2.0.2

package/package.json

@@ -1,23 +1,71 @@
-{
-  "name": "trucoshi",
-  "version": "1.0.0",
-  "main": "build/lib/trucoshi.js",
-  "license": "GPL3",
-  "scripts": {
-    "install": "yarn build",
-    "dev": "nodemon",
-    "test:autoplay": "yarn build && ts-node build/test/autoplay",
-    "test:play": "yarn build && ts-node build/test/play",
-    "build": "rimraf ./build && tsc --project ."
-  },
-  "devDependencies": {
-    "@types/node": "^18.11.18",
-    "nodemon": "^2.0.20",
-    "rimraf": "^4.1.1",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.9.4"
-  },
-  "dependencies": {
-    "socket.io": "^4.5.4"
-  }
-}
+{
+  "name": "trucoshi",
+  "version": "2.0.2",
+  "main": "dist/types.js",
+  "license": "GPL-3.0",
+  "paths": {
+    "trucoshi": [
+      "./"
+    ]
+  },
+  "scripts": {
+    "start": "nodemon",
+    "start:e2e": "dotenv -e .env.e2e -- nodemon",
+    "profiler": "yarn build && node --prof ./bin/trucoshi-server",
+    "build": "yarn run rimraf ./build && yarn run tsc --project . && yarn build:dist",
+    "build:dist": "yarn run rimraf ./dist && yarn run tsc --project ./tsconfig.dist.json",
+    "prepublishOnly": "yarn test && yarn build:dist",
+    "test": "dotenv -e .env.e2e -- yarn db:e2e:push --force-reset && dotenv -e .env.e2e -- ts-mocha --exit ./test/**/*.ts -t 50000",
+    "cli:autoplay": "yarn run ts-node src/cli/autoplay",
+    "cli:play": "yarn run ts-node src/cli/play",
+    "db:push": "prisma db push",
+    "db:studio": "prisma studio",
+    "db:migrate": "prisma migrate dev",
+    "db:e2e:push": "dotenv -e .env.e2e -- prisma db push",
+    "db:e2e:studio": "dotenv -e .env.e2e -- prisma studio",
+    "db:e2e:migrate": "dotenv -e .env.e2e -- prisma migrate dev"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.4",
+    "@types/expect": "^24.3.0",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^18.11.18",
+    "chai": "^4.3.7",
+    "mocha": "^10.2.0",
+    "nodemon": "^2.0.20",
+    "prisma": "^4.14.1",
+    "socket.io-client": "^4.5.4",
+    "ts-mocha": "^10.0.0"
+  },
+  "files": [
+    "node_modules/.prisma/client/*",
+    "dist/lib/constants.js",
+    "dist/lib/constants.d.ts",
+    "dist/types.js",
+    "dist/types.d.ts",
+    "dist/server/constants.js",
+    "dist/server/constants.d.ts"
+  ],
+  "dependencies": {
+    "@prisma/client": "^4.14.1",
+    "@socket.io/redis-adapter": "^8.2.1",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/pino": "^7.0.5",
+    "@types/redis": "^4.0.11",
+    "axios": "^1.6.3",
+    "axios-cookiejar-support": "^5.0.0",
+    "dotenv": "^16.0.3",
+    "dotenv-cli": "^7.3.0",
+    "form-data": "^4.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "lightning-accounts": "2.0.1",
+    "path-scurry": "^1.9.2",
+    "pino": "^8.11.0",
+    "pino-pretty": "^10.0.0",
+    "rimraf": "^4.1.1",
+    "socket.io": "^4.5.4",
+    "ts-node": "^10.9.1",
+    "tsc": "^2.0.4",
+    "typescript": "^5.3.3"
+  }
+}

package/.prettierrc.json

@@ -1,3 +0,0 @@
-{
-    "tabWidth": 2,
-}

package/build/lib/constants.d.ts

@@ -1,43 +0,0 @@
-export declare const CARDS: {
-    '1e': number;
-    '1b': number;
-    '7e': number;
-    '7o': number;
-    '3e': number;
-    '3o': number;
-    '3b': number;
-    '3c': number;
-    '2e': number;
-    '2o': number;
-    '2b': number;
-    '2c': number;
-    '1o': number;
-    '1c': number;
-    re: number;
-    ro: number;
-    rb: number;
-    rc: number;
-    ce: number;
-    co: number;
-    cb: number;
-    cc: number;
-    pe: number;
-    po: number;
-    pb: number;
-    pc: number;
-    '7b': number;
-    '7c': number;
-    '6e': number;
-    '6o': number;
-    '6b': number;
-    '6c': number;
-    '5e': number;
-    '5o': number;
-    '5b': number;
-    '5c': number;
-    '4e': number;
-    '4o': number;
-    '4b': number;
-    '4c': number;
-};
-export declare const COLORS: string[];

package/build/lib/constants.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COLORS = exports.CARDS = void 0;
-exports.CARDS = {
-    '1e': 14, '1b': 13, '7e': 12, '7o': 11,
-    '3e': 10, '3o': 10, '3b': 10, '3c': 10,
-    '2e': 9, '2o': 9, '2b': 8, '2c': 8,
-    '1o': 7, '1c': 7, 're': 6, 'ro': 6,
-    'rb': 6, 'rc': 6, 'ce': 5, 'co': 5,
-    'cb': 5, 'cc': 5, 'pe': 4, 'po': 4,
-    'pb': 4, 'pc': 4, '7b': 3, '7c': 3,
-    '6e': 2, '6o': 2, '6b': 2, '6c': 2,
-    '5e': 1, '5o': 1, '5b': 1, '5c': 1,
-    '4e': 0, '4o': 0, '4b': 0, '4c': 0
-};
-exports.COLORS = ["#9b111", "#17c6c6", "#8c1d1d", "#9f9b9b", "#a5a5a5", "#f5a623", "#f44336", "#c2185b"];

package/build/lib/trucoshi.d.ts

@@ -1,10 +0,0 @@
-import { IMatch, IPlayer, ITeam } from "./types";
-export declare function Match(teams?: Array<ITeam>, matchPoint?: number): IMatch;
-export declare function Player(id: string, teamIdx: number): IPlayer;
-export declare function Team(color: string, players: Array<IPlayer>): {
-    _players: Map<string, IPlayer>;
-    readonly players: IPlayer[];
-    color: string;
-    points: number;
-    addPoints(points: number): number;
-};

package/build/lib/trucoshi.js

@@ -1,363 +0,0 @@
-"use strict";
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Team = exports.Player = exports.Match = void 0;
-var constants_1 = require("./constants");
-var utils_1 = require("./utils");
-function Deck() {
-    var _deck = {
-        cards: Object.keys(constants_1.CARDS),
-        usedCards: [],
-        takeCard: function () {
-            var card = _deck.cards.shift();
-            _deck.usedCards.push(card);
-            return card;
-        },
-        shuffle: function () {
-            _deck.cards = _deck.cards.concat(_deck.usedCards);
-            _deck.usedCards = [];
-            _deck.cards = (0, utils_1.shuffleArray)(_deck.cards);
-            if (_deck.cards.length !== 40) {
-                throw new Error("This is not good");
-            }
-            return _deck;
-        }
-    };
-    return _deck;
-}
-function Table(teams, size) {
-    var _table = {
-        players: [],
-        cards: [],
-        forehandIdx: 0,
-        nextTurn: function () {
-            if (_table.forehandIdx < (size * 2) - 1) {
-                _table.forehandIdx++;
-            }
-            else {
-                _table.forehandIdx = 0;
-            }
-            return _table.player();
-        },
-        getPlayerPosition: function (id) {
-            return _table.players.findIndex(function (p) { return p.id === id; });
-        },
-        player: function (idx) {
-            if (idx !== undefined) {
-                return _table.players[idx];
-            }
-            return _table.players[_table.forehandIdx];
-        }
-    };
-    if (teams[0].players.length != size || teams[1].players.length != size) {
-        throw new Error("Unexpected team size");
-    }
-    for (var i = 0; i < size; i++) {
-        _table.players.push(teams[0].players[i]);
-        _table.players.push(teams[1].players[i]);
-    }
-    return _table;
-}
-function Round() {
-    var _round = {
-        highest: -1,
-        winner: null,
-        cards: [],
-        tie: false,
-        play: function (_a) {
-            var card = _a.card, player = _a.player;
-            var value = (0, utils_1.getCardValue)(card);
-            if (_round.highest > -1 && value === _round.highest) {
-                _round.tie = true;
-            }
-            if (value > _round.highest) {
-                _round.tie = false;
-                _round.highest = value;
-                _round.winner = player;
-            }
-            _round.cards.push({ card: card, player: player });
-            return card;
-        }
-    };
-    return _round;
-}
-function Match(teams, matchPoint) {
-    if (teams === void 0) { teams = []; }
-    if (matchPoint === void 0) { matchPoint = 9; }
-    var deck = Deck().shuffle();
-    var size = teams[0].players.length;
-    if (size !== teams[1].players.length) {
-        throw new Error("Team size mismatch");
-    }
-    function handsGeneratorSequence() {
-        var hand, value, hasWinner;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!!_match.winner) return [3 /*break*/, 4];
-                    deck.shuffle();
-                    hand = _match.setCurrentHand(Hand(_match, deck, _match.hands.length + 1));
-                    _match.pushHand(hand);
-                    _a.label = 1;
-                case 1:
-                    if (!!hand.finished) return [3 /*break*/, 3];
-                    value = hand.getNextPlayer().value;
-                    if (value && value.finished) {
-                        return [3 /*break*/, 1];
-                    }
-                    _match.setCurrentHand(value);
-                    return [4 /*yield*/, _match];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 1];
-                case 3:
-                    _match.addPoints(hand.points);
-                    _match.setCurrentHand(null);
-                    hasWinner = (0, utils_1.checkMatchWinner)(teams, matchPoint);
-                    if (hasWinner !== null) {
-                        _match.setWinner(hasWinner);
-                        _match.setCurrentHand(null);
-                    }
-                    _match.table.nextTurn();
-                    return [3 /*break*/, 0];
-                case 4: return [4 /*yield*/, _match];
-                case 5:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }
-    var handsGenerator = handsGeneratorSequence();
-    var _match = {
-        winner: null,
-        teams: teams,
-        hands: [],
-        table: Table(teams, size),
-        currentHand: null,
-        play: function () {
-            _match.getNextTurn();
-            if (!_match.currentHand) {
-                return;
-            }
-            return _match.currentHand.play();
-        },
-        addPoints: function (points) {
-            _match.teams[0].addPoints(points[0]);
-            _match.teams[1].addPoints(points[1]);
-        },
-        pushHand: function (hand) {
-            _match.hands.push(hand);
-        },
-        setCurrentHand: function (hand) {
-            _match.currentHand = hand;
-            return _match.currentHand;
-        },
-        setWinner: function (winner) {
-            _match.winner = winner;
-        },
-        getNextTurn: function () {
-            return handsGenerator.next();
-        }
-    };
-    return _match;
-}
-exports.Match = Match;
-function PlayInstance(hand) {
-    var _instance = {
-        handIdx: hand.idx,
-        roundIdx: hand.rounds.length,
-        player: hand.currentPlayer,
-        commands: [],
-        rounds: hand.rounds,
-        use: function (idx) {
-            var player = hand.currentPlayer;
-            var round = hand.currentRound;
-            if (!player || !round) {
-                return null;
-            }
-            var card = player.useCard(idx);
-            if (card) {
-                return round.play({ player: player, card: card });
-            }
-            return null;
-        },
-        say: function (command) {
-            if (!hand.currentPlayer) {
-                return null;
-            }
-            return hand;
-        }
-    };
-    return _instance;
-}
-function Hand(match, deck, idx) {
-    var truco = 1;
-    match.teams.forEach(function (team) {
-        team.players.forEach(function (player) {
-            var playerHand = [deck.takeCard(), deck.takeCard(), deck.takeCard()];
-            player.setHand(playerHand);
-            // player.setHand(["5c", "4c", "6c"])
-        });
-    });
-    function roundsGeneratorSequence() {
-        var currentRoundIdx, forehandTeamIdx, i, round, previousRound, newTurn, teamIdx;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    currentRoundIdx = 0;
-                    forehandTeamIdx = match.table.player(_hand.turn).teamIdx;
-                    _a.label = 1;
-                case 1:
-                    if (!(currentRoundIdx < 3 && !_hand.finished)) return [3 /*break*/, 5];
-                    i = 0;
-                    round = Round();
-                    _hand.setCurrentRound(round);
-                    _hand.pushRound(round);
-                    previousRound = _hand.rounds[currentRoundIdx - 1];
-                    // Put previous round winner as forehand
-                    if (previousRound && previousRound.winner && !previousRound.tie) {
-                        newTurn = match.table.getPlayerPosition(previousRound.winner.id);
-                        if (newTurn !== -1) {
-                            _hand.setTurn(newTurn);
-                        }
-                    }
-                    _a.label = 2;
-                case 2:
-                    if (!(i < match.table.players.length)) return [3 /*break*/, 4];
-                    _hand.setCurrentPlayer(match.table.player(_hand.turn));
-                    if (_hand.turn >= match.table.players.length - 1) {
-                        _hand.setTurn(0);
-                    }
-                    else {
-                        _hand.setTurn(_hand.turn + 1);
-                    }
-                    i++;
-                    return [4 /*yield*/, _hand];
-                case 3:
-                    _a.sent();
-                    return [3 /*break*/, 2];
-                case 4:
-                    teamIdx = (0, utils_1.checkHandWinner)(_hand.rounds, forehandTeamIdx);
-                    if (teamIdx !== null) {
-                        _hand.addPoints(teamIdx, truco);
-                        _hand.setFinished(true);
-                    }
-                    currentRoundIdx++;
-                    return [3 /*break*/, 1];
-                case 5: return [4 /*yield*/, _hand];
-                case 6:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }
-    var roundsGenerator = roundsGeneratorSequence();
-    var _hand = {
-        idx: idx,
-        turn: Number(match.table.forehandIdx),
-        rounds: [],
-        finished: false,
-        points: {
-            0: 0,
-            1: 0
-        },
-        currentRound: null,
-        currentPlayer: null,
-        play: function () {
-            return PlayInstance(_hand);
-        },
-        pushRound: function (round) {
-            _hand.rounds.push(round);
-            return round;
-        },
-        setTurn: function (turn) {
-            _hand.turn = turn;
-            return match.table.player(_hand.turn);
-        },
-        addPoints: function (team, points) {
-            _hand.points[team] = _hand.points[team] + points;
-        },
-        setCurrentRound: function (round) {
-            _hand.currentRound = round;
-            return _hand.currentRound;
-        },
-        setCurrentPlayer: function (player) {
-            _hand.currentPlayer = player;
-            return _hand.currentPlayer;
-        },
-        setFinished: function (finshed) {
-            _hand.finished = finshed;
-            return _hand.finished;
-        },
-        getNextPlayer: function () {
-            return roundsGenerator.next();
-        },
-    };
-    return _hand;
-}
-function Player(id, teamIdx) {
-    var _player = {
-        id: id,
-        teamIdx: teamIdx,
-        hand: [],
-        usedHand: [],
-        setHand: function (hand) {
-            _player.hand = hand;
-            _player.usedHand = [];
-            return hand;
-        },
-        useCard: function (idx) {
-            if (_player.hand[idx]) {
-                var card = _player.hand.splice(idx, 1)[0];
-                _player.usedHand.push(card);
-                return card;
-            }
-            return null;
-        }
-    };
-    return _player;
-}
-exports.Player = Player;
-function Team(color, players) {
-    var _team = {
-        _players: new Map(),
-        get players() {
-            return Array.from(_team._players.values());
-        },
-        color: color,
-        points: 0,
-        addPoints: function (points) {
-            _team.points += points;
-            return _team.points;
-        },
-    };
-    players.forEach(function (player) { return _team._players.set(player.id, player); });
-    return _team;
-}
-exports.Team = Team;

package/build/lib/types.d.ts

@@ -1,101 +0,0 @@
-import { CARDS } from "./constants";
-export type ICard = keyof typeof CARDS;
-export interface IDeck {
-    cards: Array<ICard>;
-    usedCards: Array<ICard>;
-    takeCard(): ICard;
-    shuffle(): IDeck;
-}
-export interface IPlayedCard {
-    player: IPlayer;
-    card: ICard;
-}
-export interface IPlayer {
-    teamIdx: number;
-    id: string;
-    hand: Array<ICard>;
-    usedHand: Array<ICard>;
-    setHand(hand: Array<ICard>): Array<ICard>;
-    useCard(idx: number): ICard | null;
-}
-export interface ITeam {
-    color: string;
-    _players: Map<string, IPlayer>;
-    players: Array<IPlayer>;
-    points: number;
-    addPoints(points: number): number;
-}
-export interface IMatch {
-    teams: [ITeam, ITeam];
-    hands: Array<IHand>;
-    winner: ITeam | null;
-    currentHand: IHand | null;
-    table: ITable;
-    play(): IPlayInstance | undefined;
-    addPoints(points: IPoints): void;
-    pushHand(hand: IHand): void;
-    setCurrentHand(hand: IHand | null): IHand | null;
-    setWinner(winner: ITeam): void;
-    getNextTurn(): IteratorResult<IMatch | null, IMatch | null | void>;
-}
-export type IPoints = {
-    0: number;
-    1: number;
-    2?: number;
-};
-export type IGetNextPlayerResult = {
-    currentPlayer?: IPlayer;
-    currentRound?: IRound;
-    points?: IPoints;
-};
-export declare enum EHandPlayCommand {
-    TRUCO = 0,
-    ENVIDO = 1,
-    ENVIDO_ENVIDO = 2,
-    REAL_ENVIDO = 3,
-    FALTA_ENVIDO = 4,
-    MAZO = 5,
-    FLOR = 6,
-    CONTRAFLOR = 7
-}
-export interface IPlayInstance {
-    handIdx: number;
-    roundIdx: number;
-    player: IPlayer | null;
-    commands: Array<EHandPlayCommand> | null;
-    rounds: Array<IRound> | null;
-    use(idx: number): ICard | null;
-    say(command: EHandPlayCommand): IHand | null;
-}
-export interface IHand {
-    idx: number;
-    turn: number;
-    finished: boolean;
-    points: IPoints;
-    rounds: Array<IRound>;
-    currentPlayer: IPlayer | null;
-    currentRound: IRound | null;
-    play(): IPlayInstance;
-    pushRound(round: IRound): IRound;
-    setTurn(turn: number): IPlayer;
-    addPoints(team: 0 | 1, points: number): void;
-    setCurrentRound(round: IRound | null): IRound | null;
-    setCurrentPlayer(player: IPlayer | null): IPlayer | null;
-    setFinished(finshed: boolean): boolean;
-    getNextPlayer(): IteratorResult<IHand, IHand | void>;
-}
-export interface ITable {
-    forehandIdx: number;
-    cards: Array<Array<IPlayedCard>>;
-    players: Array<IPlayer>;
-    nextTurn(): IPlayer;
-    player(idx?: number): IPlayer;
-    getPlayerPosition(id: string): number;
-}
-export interface IRound {
-    tie: boolean;
-    winner: IPlayer | null;
-    highest: number;
-    cards: Array<IPlayedCard>;
-    play(playedCard: IPlayedCard): ICard;
-}

package/build/lib/types.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EHandPlayCommand = void 0;
-var EHandPlayCommand;
-(function (EHandPlayCommand) {
-    EHandPlayCommand[EHandPlayCommand["TRUCO"] = 0] = "TRUCO";
-    EHandPlayCommand[EHandPlayCommand["ENVIDO"] = 1] = "ENVIDO";
-    EHandPlayCommand[EHandPlayCommand["ENVIDO_ENVIDO"] = 2] = "ENVIDO_ENVIDO";
-    EHandPlayCommand[EHandPlayCommand["REAL_ENVIDO"] = 3] = "REAL_ENVIDO";
-    EHandPlayCommand[EHandPlayCommand["FALTA_ENVIDO"] = 4] = "FALTA_ENVIDO";
-    EHandPlayCommand[EHandPlayCommand["MAZO"] = 5] = "MAZO";
-    EHandPlayCommand[EHandPlayCommand["FLOR"] = 6] = "FLOR";
-    EHandPlayCommand[EHandPlayCommand["CONTRAFLOR"] = 7] = "CONTRAFLOR";
-})(EHandPlayCommand = exports.EHandPlayCommand || (exports.EHandPlayCommand = {}));

package/build/lib/utils.d.ts

@@ -1,5 +0,0 @@
-import { ICard, IRound, ITeam } from "./types";
-export declare function getCardValue(card: ICard): number;
-export declare function shuffleArray<T = never>(array: Array<T>): T[];
-export declare function checkHandWinner(rounds: Array<IRound>, forehandTeamIdx: 0 | 1): null | 0 | 1;
-export declare function checkMatchWinner(teams: Array<ITeam>, matchPoint: number): ITeam | null;