trucoshi 0.1.8 → 0.2.1

package/dist/lib/classes/Match.js

@@ -1,112 +1,69 @@
 "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.Match = void 0;
-var Deck_1 = require("./Deck");
-var Hand_1 = require("./Hand");
-function Match(table, teams, matchPoint) {
-    if (teams === void 0) { teams = []; }
-    if (matchPoint === void 0) { matchPoint = 9; }
-    var deck = (0, Deck_1.Deck)().shuffle();
-    var size = teams[0].players.length;
+const Deck_1 = require("./Deck");
+const Hand_1 = require("./Hand");
+function Match(table, teams = [], matchPoint = 9) {
+    const deck = (0, Deck_1.Deck)().shuffle();
+    const size = teams[0].players.length;
     if (size !== teams[1].players.length) {
         throw new Error("Team size mismatch");
     }
-    function handsGeneratorSequence() {
-        var hand, value, teams_1, winner;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!!match.winner) return [3 /*break*/, 4];
-                    deck.shuffle();
-                    hand = match.setCurrentHand((0, Hand_1.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.setCurrentHand(null);
-                    teams_1 = match.addPoints(hand.points);
-                    winner = teams_1.find(function (team) { return team.points.winner; });
-                    if (winner) {
-                        match.setWinner(winner);
-                        match.setCurrentHand(null);
-                        return [3 /*break*/, 4];
-                    }
-                    match.table.nextTurn();
-                    return [3 /*break*/, 0];
-                case 4: return [4 /*yield*/, match];
-                case 5:
-                    _a.sent();
-                    return [2 /*return*/];
+    function* handsGeneratorSequence() {
+        while (!match.winner) {
+            deck.shuffle();
+            const hand = match.setCurrentHand((0, Hand_1.Hand)(match, deck, match.hands.length + 1));
+            match.pushHand(hand);
+            while (!hand.finished()) {
+                const { value } = hand.getNextPlayer();
+                if (value && value.finished()) {
+                    continue;
+                }
+                match.setCurrentHand(value);
+                yield match;
+            }
+            match.setCurrentHand(null);
+            const teams = match.addPoints(hand.points);
+            const winner = teams.find((team) => team.points.winner);
+            if (winner) {
+                match.setWinner(winner);
+                match.setCurrentHand(null);
+                break;
             }
-        });
+            match.table.nextTurn();
+        }
+        yield match;
     }
-    var handsGenerator = handsGeneratorSequence();
-    var match = {
+    const handsGenerator = handsGeneratorSequence();
+    const match = {
         winner: null,
         teams: teams,
         hands: [],
-        table: table,
+        table,
         currentHand: null,
-        play: function () {
+        play() {
             match.getNextTurn();
             if (!match.currentHand) {
                 return null;
             }
             return match.currentHand.play();
         },
-        addPoints: function (points) {
+        addPoints(points) {
             match.teams[0].addPoints(matchPoint, points[0]);
             match.teams[1].addPoints(matchPoint, points[1]);
             return match.teams;
         },
-        pushHand: function (hand) {
+        pushHand(hand) {
             match.hands.push(hand);
         },
-        setCurrentHand: function (hand) {
+        setCurrentHand(hand) {
             match.currentHand = hand;
             return match.currentHand;
         },
-        setWinner: function (winner) {
+        setWinner(winner) {
             match.winner = winner;
         },
-        getNextTurn: function () {
+        getNextTurn() {
             return handsGenerator.next();
         },
     };

package/dist/lib/classes/Play.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlayInstance = void 0;
-var types_1 = require("../../types");
+const types_1 = require("../../types");
 function PlayInstance(hand, teams) {
     var _a, _b, _c;
-    var instance = {
+    const instance = {
         state: hand.state,
-        teams: teams,
+        teams,
         truco: hand.truco,
         envido: hand.envido,
         handIdx: hand.idx,
@@ -14,10 +14,10 @@ function PlayInstance(hand, teams) {
         player: hand.currentPlayer,
         commands: [],
         rounds: hand.rounds,
-        use: function (idx, card) {
+        use(idx, card) {
             return hand.use(idx, card);
         },
-        say: function (command) {
+        say(command) {
             var _a;
             if (!hand._currentPlayer || !((_a = instance.commands) === null || _a === void 0 ? void 0 : _a.includes(command))) {
                 return null;

package/dist/lib/classes/Player.js

@@ -1,73 +1,63 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Player = void 0;
-function Player(id, teamIdx, isOwner) {
-    if (isOwner === void 0) { isOwner = false; }
-    var player = {
-        id: id,
+function Player(id, teamIdx, isOwner = false) {
+    const player = {
+        id,
         session: undefined,
-        teamIdx: teamIdx,
+        teamIdx,
         hand: [],
         commands: [],
         usedHand: [],
         prevHand: [],
-        isOwner: isOwner,
+        isOwner,
         isTurn: false,
         disabled: false,
         ready: false,
-        setOwner: function (owner) {
+        setOwner(owner) {
             player.isOwner = owner;
         },
-        setTurn: function (turn) {
+        setTurn(turn) {
             player.isTurn = turn;
         },
-        getPublicPlayer: function () {
-            var id = player.id, disabled = player.disabled, ready = player.ready, usedHand = player.usedHand, prevHand = player.prevHand, teamIdx = player.teamIdx, isTurn = player.isTurn, isOwner = player.isOwner;
+        getPublicPlayer() {
+            const { id, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner } = player;
             return {
-                id: id,
-                disabled: disabled,
-                ready: ready,
-                usedHand: usedHand,
-                prevHand: prevHand,
-                teamIdx: teamIdx,
-                isTurn: isTurn,
-                isOwner: isOwner,
-                hand: player.hand.map(function () { return "xx"; }),
+                id,
+                disabled,
+                ready,
+                usedHand,
+                prevHand,
+                teamIdx,
+                isTurn,
+                isOwner,
+                hand: player.hand.map(() => "xx"),
                 session: undefined,
             };
         },
-        setSession: function (session) {
+        setSession(session) {
             player.session = session;
         },
-        enable: function () {
+        enable() {
             player.disabled = false;
         },
-        disable: function () {
+        disable() {
             player.disabled = true;
         },
-        setReady: function (ready) {
+        setReady(ready) {
             player.ready = ready;
         },
-        setHand: function (hand) {
-            player.prevHand = __spreadArray([], player.usedHand, true);
+        setHand(hand) {
+            player.prevHand = [...player.usedHand];
             player.hand = hand;
             player.usedHand = [];
             return hand;
         },
-        useCard: function (idx, card) {
+        useCard(idx, card) {
             if (player.hand[idx] && player.hand[idx] === card) {
-                var card_1 = player.hand.splice(idx, 1)[0];
-                player.usedHand.push(card_1);
-                return card_1;
+                const card = player.hand.splice(idx, 1)[0];
+                player.usedHand.push(card);
+                return card;
             }
             return null;
         },

package/dist/lib/classes/Round.js

@@ -1,23 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Round = void 0;
-var utils_1 = require("../utils");
-var Deck_1 = require("./Deck");
+const utils_1 = require("../utils");
+const Deck_1 = require("./Deck");
 function Round(turn) {
-    var round = {
-        turn: turn,
+    const round = {
+        turn,
         highest: -1,
         winner: null,
         cards: [],
         tie: false,
-        nextTurn: function () {
+        nextTurn() {
             round.turn++;
         },
-        use: function (_a) {
-            var _b;
-            var card = _a.card, player = _a.player;
-            var value = (0, utils_1.getCardValue)(card);
-            if (value === round.highest && player.teamIdx !== ((_b = round.winner) === null || _b === void 0 ? void 0 : _b.teamIdx)) {
+        use({ card, player }) {
+            var _a;
+            const value = (0, utils_1.getCardValue)(card);
+            if (value === round.highest && player.teamIdx !== ((_a = round.winner) === null || _a === void 0 ? void 0 : _a.teamIdx)) {
                 round.tie = true;
             }
             if (value > round.highest) {

package/dist/lib/classes/Table.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = void 0;
 function Table(players, teams) {
-    var table = {
-        players: players,
+    const table = {
+        players,
         cards: [],
         forehandIdx: 0,
-        nextTurn: function () {
+        nextTurn() {
             if (table.forehandIdx < table.players.length - 1) {
                 table.forehandIdx++;
             }
@@ -15,10 +15,10 @@ function Table(players, teams) {
             }
             return table.player();
         },
-        getPlayerPosition: function (id) {
-            return table.players.findIndex(function (p) { return p.id === id; });
+        getPlayerPosition(id) {
+            return table.players.findIndex((p) => p.id === id);
         },
-        player: function (idx) {
+        player(idx) {
             if (idx !== undefined) {
                 return table.players[idx];
             }

package/dist/lib/classes/Team.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Team = void 0;
 function Team(players) {
-    var team = {
+    const team = {
         _players: new Map(),
         get players() {
             return Array.from(team._players.values());
@@ -12,25 +12,23 @@ function Team(players) {
             malas: 0,
             winner: false,
         },
-        getPublicTeam: function (playerSession) {
+        getPublicTeam(playerSession) {
             return {
                 points: team.points,
-                players: team.players.map(function (player) {
-                    return player.session === playerSession ? player : player.getPublicPlayer();
-                }),
+                players: team.players.map((player) => player.session === playerSession ? player : player.getPublicPlayer()),
             };
         },
-        isTeamDisabled: function () {
-            return team.players.reduce(function (prev, curr) { return prev && curr.disabled; }, true);
+        isTeamDisabled() {
+            return team.players.reduce((prev, curr) => prev && curr.disabled, true);
         },
-        disable: function (player) {
+        disable(player) {
             var _a;
             (_a = team._players.get(player.session)) === null || _a === void 0 ? void 0 : _a.disable();
             return team.isTeamDisabled();
         },
-        addPoints: function (matchPoint, points) {
-            var malas = team.points.malas + points;
-            var diff = malas - matchPoint;
+        addPoints(matchPoint, points) {
+            const malas = team.points.malas + points;
+            const diff = malas - matchPoint;
             if (diff > 0) {
                 team.points.malas = matchPoint;
                 team.points.buenas += diff;
@@ -44,7 +42,7 @@ function Team(players) {
             return team.points;
         },
     };
-    players.forEach(function (player) { return team._players.set(player.session, player); });
+    players.forEach((player) => team._players.set(player.session, player));
     return team;
 }
 exports.Team = Team;

package/dist/lib/classes/Truco.js

@@ -1,67 +1,27 @@
 "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.Truco = void 0;
 function Truco() {
-    function trucoAnswerGeneratorSequence() {
-        var i, player;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    i = 0;
-                    _a.label = 1;
-                case 1:
-                    if (!(i < truco.players.length && truco.answer === null)) return [3 /*break*/, 3];
-                    player = truco.players[truco.turn];
-                    truco.setCurrentPlayer(player);
-                    if (player.disabled) {
-                        truco.setCurrentPlayer(null);
-                    }
-                    if (truco.turn >= truco.players.length - 1) {
-                        truco.setTurn(0);
-                    }
-                    else {
-                        truco.setTurn(truco.turn + 1);
-                    }
-                    i++;
-                    return [4 /*yield*/, truco];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 1];
-                case 3: return [4 /*yield*/, truco];
-                case 4:
-                    _a.sent();
-                    return [2 /*return*/];
+    function* trucoAnswerGeneratorSequence() {
+        let i = 0;
+        while (i < truco.players.length && truco.answer === null) {
+            const player = truco.players[truco.turn];
+            truco.setCurrentPlayer(player);
+            if (player.disabled) {
+                truco.setCurrentPlayer(null);
+            }
+            if (truco.turn >= truco.players.length - 1) {
+                truco.setTurn(0);
+            }
+            else {
+                truco.setTurn(truco.turn + 1);
             }
-        });
+            i++;
+            yield truco;
+        }
+        yield truco;
     }
-    var truco = {
+    const truco = {
         turn: 0,
         state: 1,
         teamIdx: null,
@@ -69,17 +29,17 @@ function Truco() {
         currentPlayer: null,
         generator: trucoAnswerGeneratorSequence(),
         players: [],
-        sayTruco: function (teamIdx, players) {
+        sayTruco(teamIdx, players) {
             truco.teamIdx = teamIdx;
             truco.answer = null;
             truco.players = players;
             truco.generator = trucoAnswerGeneratorSequence();
             return truco;
         },
-        setPlayers: function (players) {
+        setPlayers(players) {
             truco.players = players;
         },
-        setAnswer: function (answer) {
+        setAnswer(answer) {
             if (answer) {
                 truco.state++;
             }
@@ -89,19 +49,19 @@ function Truco() {
             truco.answer = answer;
             return truco;
         },
-        setTeam: function (idx) {
+        setTeam(idx) {
             truco.teamIdx = idx;
             return truco.teamIdx;
         },
-        setTurn: function (turn) {
+        setTurn(turn) {
             truco.turn = turn;
             return truco.turn;
         },
-        setCurrentPlayer: function (player) {
+        setCurrentPlayer(player) {
             truco.currentPlayer = player;
             return truco.currentPlayer;
         },
-        getNextPlayer: function () {
+        getNextPlayer() {
             return truco.generator.next();
         },
     };

package/dist/lib/constants.js

@@ -1,9 +1,8 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnvidoCalculator = exports.TEAM_SIZE_VALUES = exports.CARDS = void 0;
-var types_1 = require("../types");
-var utils_1 = require("./utils");
+const types_1 = require("../types");
+const utils_1 = require("./utils");
 exports.CARDS = {
     "1e": 14,
     "1b": 13,
@@ -47,23 +46,23 @@ exports.CARDS = {
     "4c": 0,
 };
 exports.TEAM_SIZE_VALUES = [1, 2, 3];
-exports.EnvidoCalculator = (_a = {},
-    _a[types_1.EEnvidoCommand.ENVIDO] = function () { return ({
+exports.EnvidoCalculator = {
+    [types_1.EEnvidoCommand.ENVIDO]: () => ({
         accept: 2,
         decline: 1,
         next: [types_1.EEnvidoCommand.ENVIDO_ENVIDO, types_1.EEnvidoCommand.REAL_ENVIDO, types_1.EEnvidoCommand.FALTA_ENVIDO],
-    }); },
-    _a[types_1.EEnvidoCommand.ENVIDO_ENVIDO] = function () { return ({
+    }),
+    [types_1.EEnvidoCommand.ENVIDO_ENVIDO]: () => ({
         accept: 4,
         decline: 2,
         next: [types_1.EEnvidoCommand.REAL_ENVIDO, types_1.EEnvidoCommand.FALTA_ENVIDO],
-    }); },
-    _a[types_1.EEnvidoCommand.REAL_ENVIDO] = function () { return ({
+    }),
+    [types_1.EEnvidoCommand.REAL_ENVIDO]: () => ({
         accept: 3,
         decline: 1,
         next: [types_1.EEnvidoCommand.FALTA_ENVIDO],
-    }); },
-    _a[types_1.EEnvidoCommand.FALTA_ENVIDO] = function (args) {
+    }),
+    [types_1.EEnvidoCommand.FALTA_ENVIDO]: (args) => {
         if (!args || !args.teams || !args.matchPoint) {
             return {
                 accept: 1,
@@ -71,15 +70,15 @@ exports.EnvidoCalculator = (_a = {},
                 next: [],
             };
         }
-        var teams = args.teams, matchPoint = args.matchPoint;
-        var totals = teams.map(function (team) { return team.points.malas + team.points.buenas; });
-        var higher = (0, utils_1.getMaxNumberIndex)(totals);
-        var points = teams[higher].points;
-        var accept = points.buenas > 0 ? matchPoint - points.buenas : matchPoint - points.malas;
+        const { teams, matchPoint } = args;
+        const totals = teams.map((team) => team.points.malas + team.points.buenas);
+        const higher = (0, utils_1.getMaxNumberIndex)(totals);
+        const points = teams[higher].points;
+        const accept = points.buenas > 0 ? matchPoint - points.buenas : matchPoint - points.malas;
         return {
-            accept: accept,
+            accept,
             decline: 2,
             next: [],
         };
     },
-    _a);
+};

package/dist/lib/utils.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkHandWinner = exports.shuffleArray = exports.getCardValue = exports.getMaxNumberIndex = void 0;
-var constants_1 = require("./constants");
+const constants_1 = require("./constants");
 function getMaxNumberIndex(array) {
-    return array.reduce(function (accumulator, current, index) {
+    return array.reduce((accumulator, current, index) => {
         return current > array[accumulator] ? index : accumulator;
     }, 0);
 }
@@ -13,25 +13,24 @@ function getCardValue(card) {
 }
 exports.getCardValue = getCardValue;
 function shuffleArray(array) {
-    var _a;
-    var currentIndex = array.length, randomIndex;
+    let currentIndex = array.length, randomIndex;
     while (currentIndex != 0) {
         randomIndex = Math.floor(Math.random() * currentIndex);
         currentIndex--;
-        _a = [array[randomIndex], array[currentIndex]], array[currentIndex] = _a[0], array[randomIndex] = _a[1];
+        [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
     }
     return array;
 }
 exports.shuffleArray = shuffleArray;
 function checkHandWinner(rounds, forehandTeamIdx) {
     var _a, _b;
-    var roundsWon = {
+    const roundsWon = {
         0: 0,
         1: 0,
         ties: 0,
     };
-    for (var i = 0; i < rounds.length; i++) {
-        var round = rounds[i];
+    for (let i = 0; i < rounds.length; i++) {
+        const round = rounds[i];
         if (round.tie) {
             roundsWon[0] += 1;
             roundsWon[1] += 1;