@gamepark/react-client 7.0.0-beta.0 → 7.0.0-beta.2

package/dist/api/Local/GameLocalAPI.js

@@ -1,144 +1,90 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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());
-    });
-};
-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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["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 };
-    }
-};
-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));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GameLocalAPI = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var assert_1 = __importDefault(require("assert"));
-var Actions_1 = require("../../Actions");
-var Failure_1 = require("../../Failure");
-var Types_1 = require("../../Types");
-var ArrayUtil_1 = require("../../util/ArrayUtil");
-var GameLocalAPI = (function () {
-    function GameLocalAPI(_a) {
-        var Rules = _a.Rules, ServerRules = _a.ServerRules, GameSetup = _a.GameSetup, ai = _a.ai, game = _a.game, storage = _a.storage, optionsSpec = _a.optionsSpec, tutorial = _a.tutorial;
-        this.lastActionId = 0;
-        this.notificationsCount = 0;
-        this.autoPlayersCounter = 0;
-        this.aiProcessing = false;
-        this.tutorialMovesToPlay = 0;
-        this.storage = storage !== null && storage !== void 0 ? storage : game;
-        this.Rules = ServerRules !== null && ServerRules !== void 0 ? ServerRules : Rules;
+import { applyAutomaticMoves, generatePlayersOption, getGameView, getMoveView, hasHiddenInformation, hasSecretInformation, hasUndo, isSecretAction, isWithPlayerIdOptions, isWithPlayerOptions, playAction, playActionWithViews, RandomBot, replayActions } from '@gamepark/rules-api';
+import assert from 'assert';
+import { receiveNotifications, setAnimationsSpeed, setGameOver } from '../../Actions';
+import { loadGameState } from '../../Actions/loadGameState';
+import { reportFailure } from '../../Actions/reportFailure';
+import { Failure } from '../../Failure';
+import { GameMode, GameSpeed, movePlayedNotification, moveUndoneNotification } from '../../Types';
+import { findLastIndex } from '../../util/ArrayUtil';
+export class GameLocalAPI {
+    storage;
+    gameSetup;
+    Rules;
+    ClientRules;
+    optionsSpec;
+    ai;
+    tutorial;
+    dispatch;
+    lastActionId = 0;
+    notificationsCount = 0;
+    autoPlayersCounter = 0;
+    aiProcessing = false;
+    tutorialMovesToPlay = 0;
+    constructor({ Rules, ServerRules, GameSetup, ai, game, storage, optionsSpec, tutorial }) {
+        this.storage = storage ?? game;
+        this.Rules = ServerRules ?? Rules;
         this.gameSetup = new GameSetup();
         this.ClientRules = Rules;
         this.optionsSpec = optionsSpec;
         this.ai = ai;
         this.tutorial = tutorial;
     }
-    GameLocalAPI.prototype.init = function (dispatch) {
-        var _this = this;
-        var _a;
+    init(dispatch) {
         this.dispatch = dispatch;
-        var animationsSpeed = parseFloat(localStorage.getItem('animationsSpeed') || '1');
-        this.dispatch((0, Actions_1.setAnimationsSpeed)(animationsSpeed));
-        var data = this.initLocalStore();
-        var visibleActions = data.actions.filter(function (action) { return !(0, rules_api_1.isSecretAction)(action) || !action.secrets.some(function (secret) { return secret.recipient === data.playerId; }); });
-        var notifications = this.getNotifications(data);
+        const animationsSpeed = parseFloat(localStorage.getItem('animationsSpeed') || '1');
+        this.dispatch(setAnimationsSpeed(animationsSpeed));
+        const data = this.initLocalStore();
+        const visibleActions = data.actions.filter(action => !isSecretAction(action) || !action.secrets.some(secret => secret.recipient === data.playerId));
+        const notifications = this.getNotifications(data);
         this.notificationsCount = notifications.length;
-        var dataToTransfer = {
-            myPlayerId: data.playerId, setup: data.setup, state: data.state,
-            notifications: notifications,
-            players: data.players, options: (_a = data.options) !== null && _a !== void 0 ? _a : { speed: Types_1.GameSpeed.Disabled, maxSpareTime: 0, maxExceedTime: 0 },
-            mode: data.tutorial ? Types_1.GameMode.TUTORIAL : Types_1.GameMode.FRIENDLY, notificationsChannel: '', endDate: null, tournament: null
+        const dataToTransfer = {
+            myPlayerId: data.playerId, setup: data.setup, state: data.state, notifications,
+            players: data.players, options: data.options ?? { speed: GameSpeed.Disabled, maxSpareTime: 0, maxExceedTime: 0 },
+            mode: data.tutorial ? GameMode.TUTORIAL : GameMode.FRIENDLY, notificationsChannel: '', endDate: null, tournament: null
         };
-        var initialGame = new this.Rules(JSON.parse(JSON.stringify(data.setup)));
-        var rules = new this.Rules(data.state);
-        var isOver = rules.isOver(data.players.map(function (p) { return p.id; }));
+        const initialGame = new this.Rules(JSON.parse(JSON.stringify(data.setup)));
+        const rules = new this.Rules(data.state);
+        const isOver = rules.isOver(data.players.map(p => p.id));
         if (isOver) {
             dataToTransfer.endDate = new Date();
         }
-        if ((0, rules_api_1.hasHiddenInformation)(initialGame) && !isOver) {
-            dataToTransfer.setup = verifyNonMutation(function () { return (0, rules_api_1.getGameView)(initialGame, data.playerId); }, function () { return initialGame.game; }, 'getView must not change the game state');
+        if (hasHiddenInformation(initialGame) && !isOver) {
+            dataToTransfer.setup = verifyNonMutation(() => getGameView(initialGame, data.playerId), () => initialGame.game, 'getView must not change the game state');
             if (visibleActions.length < data.actions.length) {
                 dataToTransfer.setup = JSON.parse(JSON.stringify(dataToTransfer.setup));
-                (0, rules_api_1.replayActions)(initialGame, visibleActions);
-                dataToTransfer.state = verifyNonMutation(function () { return (0, rules_api_1.getGameView)(initialGame, data.playerId); }, function () { return initialGame.game; }, 'getView must not change the game state');
+                replayActions(initialGame, visibleActions);
+                dataToTransfer.state = verifyNonMutation(() => getGameView(initialGame, data.playerId), () => initialGame.game, 'getView must not change the game state');
             }
             else {
-                if ((0, rules_api_1.hasHiddenInformation)(rules)) {
-                    dataToTransfer.state = verifyNonMutation(function () { return (0, rules_api_1.getGameView)(rules, data.playerId); }, function () { return rules.game; }, 'getView must not change the game state');
+                if (hasHiddenInformation(rules)) {
+                    dataToTransfer.state = verifyNonMutation(() => getGameView(rules, data.playerId), () => rules.game, 'getView must not change the game state');
                 }
             }
         }
-        mimicDataTransfer(dataToTransfer).then(function (gameData) { return _this.dispatch((0, Actions_1.gameStateLoaded)(gameData)); });
-    };
-    GameLocalAPI.prototype.initLocalStore = function () {
-        var _a;
-        var localStore = localStorage.getItem(this.storage);
+        mimicDataTransfer(dataToTransfer).then(gameData => this.dispatch(loadGameState({
+            ...(gameData), playerId: gameData.myPlayerId ?? undefined, serverTime: undefined, endDate: gameData.endDate ?? undefined,
+            tournament: gameData.tournament ?? undefined
+        })));
+    }
+    initLocalStore() {
+        const localStore = localStorage.getItem(this.storage);
         if (localStore) {
-            var data = JSON.parse(localStore);
+            const data = JSON.parse(localStore);
             if (process.env.NODE_ENV !== 'development' && this.tutorial && !data.tutorial) {
                 return this.newTutorial();
             }
-            if (((_a = this.tutorial) === null || _a === void 0 ? void 0 : _a.version) && data.tutorial && data.tutorial !== this.tutorial.version) {
+            if (this.tutorial?.version && data.tutorial && data.tutorial !== this.tutorial.version) {
                 return this.newTutorial();
             }
             if (data.actions.length > 0 && !data.actions[0].id) {
-                data.actions.forEach(function (action, index) {
+                data.actions.forEach((action, index) => {
                     if (!action.id)
                         action.id = index.toString();
                 });
                 localStorage.setItem(this.storage, JSON.stringify(data));
             }
             if (data.actions.length > 0) {
-                var lastActionId = parseInt(data.actions[data.actions.length - 1].id);
+                const lastActionId = parseInt(data.actions[data.actions.length - 1].id);
                 if (!isNaN(lastActionId)) {
                     this.lastActionId = lastActionId;
                 }
@@ -148,38 +94,30 @@ var GameLocalAPI = (function () {
         else {
             return this.tutorial ? this.newTutorial() : this.newGame();
         }
-    };
-    GameLocalAPI.prototype.getNotifications = function (data) {
-        var rules = new this.Rules(JSON.parse(JSON.stringify(data.setup)));
-        var actions = data.actions.filter(function (action) { return !(0, rules_api_1.isSecretAction)(action) || !action.secrets.some(function (secret) { return secret.recipient === data.playerId; }); });
-        if ((0, rules_api_1.hasHiddenInformation)(rules) && !new this.Rules(data.state).isOver(data.players.map(function (p) { return p.id; }))) {
-            var clientGame = new this.ClientRules(JSON.parse(JSON.stringify((0, rules_api_1.getGameView)(rules, data.playerId))), { player: data.playerId });
-            var notifications = [];
-            var _loop_1 = function (action) {
-                var moveView = verifyNonMutation(function () { return (0, rules_api_1.getMoveView)(rules, JSON.parse(JSON.stringify(action.move)), data.playerId); }, function () { return rules.game; }, 'getMoveView must not change the state of the game');
+    }
+    getNotifications(data) {
+        const rules = new this.Rules(JSON.parse(JSON.stringify(data.setup)));
+        const actions = data.actions.filter(action => !isSecretAction(action) || !action.secrets.some(secret => secret.recipient === data.playerId));
+        if (hasHiddenInformation(rules) && !new this.Rules(data.state).isOver(data.players.map(p => p.id))) {
+            const clientGame = new this.ClientRules(JSON.parse(JSON.stringify(getGameView(rules, data.playerId))), { player: data.playerId });
+            const notifications = [];
+            for (const action of actions) {
+                const moveView = verifyNonMutation(() => getMoveView(rules, JSON.parse(JSON.stringify(action.move)), data.playerId), () => rules.game, 'getMoveView must not change the state of the game');
                 clientGame.play(JSON.parse(JSON.stringify(moveView)));
                 rules.play(JSON.parse(JSON.stringify(action.move)));
-                var consequences = [];
-                var _loop_2 = function (move) {
-                    var moveView_1 = verifyNonMutation(function () { return (0, rules_api_1.getMoveView)(rules, JSON.parse(JSON.stringify(move)), data.playerId); }, function () { return rules.game; }, 'getMoveView must not change the state of the game');
-                    consequences.push(moveView_1);
-                    clientGame.play(JSON.parse(JSON.stringify(moveView_1)));
+                const consequences = [];
+                for (const move of action.consequences) {
+                    const moveView = verifyNonMutation(() => getMoveView(rules, JSON.parse(JSON.stringify(move)), data.playerId), () => rules.game, 'getMoveView must not change the state of the game');
+                    consequences.push(moveView);
+                    clientGame.play(JSON.parse(JSON.stringify(moveView)));
                     rules.play(JSON.parse(JSON.stringify(move)));
-                };
-                for (var _a = 0, _b = action.consequences; _a < _b.length; _a++) {
-                    var move = _b[_a];
-                    _loop_2(move);
                 }
-                notifications.push((0, Types_1.movePlayedNotification)(__assign(__assign({}, action), { move: moveView, consequences: consequences })));
-            };
-            for (var _i = 0, actions_1 = actions; _i < actions_1.length; _i++) {
-                var action = actions_1[_i];
-                _loop_1(action);
+                notifications.push(movePlayedNotification({ ...action, move: moveView, consequences }));
             }
-            var serverGameView = JSON.parse(JSON.stringify((0, rules_api_1.getGameView)(rules, data.playerId)), function (_, value) { return sortObjectKeys(value); });
-            var clientGameView = JSON.parse(JSON.stringify(clientGame.game), function (_, value) { return sortObjectKeys(value); });
+            const serverGameView = JSON.parse(JSON.stringify(getGameView(rules, data.playerId)), (_, value) => sortObjectKeys(value));
+            const clientGameView = JSON.parse(JSON.stringify(clientGame.game), (_, value) => sortObjectKeys(value));
             try {
-                assert_1.default.deepStrictEqual(serverGameView, clientGameView);
+                assert.deepStrictEqual(serverGameView, clientGameView);
             }
             catch (e) {
                 console.error('Something is wrong with rules.getView or rules.getMoveView implementation: the view is not the same when moveViews are applied');
@@ -190,351 +128,314 @@ var GameLocalAPI = (function () {
             return notifications;
         }
         else {
-            return actions.map(function (action) { return (0, Types_1.movePlayedNotification)(action); });
+            return actions.map(action => movePlayedNotification(action));
         }
-    };
-    GameLocalAPI.prototype.newTutorial = function () {
-        var _a;
+    }
+    newTutorial() {
         if (!this.tutorial) {
             throw new Error('Pass a Tutorial in the options of createGameStore first');
         }
-        var _b = this.tutorial.setupTutorial(), state = _b[0], players = _b[1];
-        return this.initGameStore(state, players, (_a = this.tutorial.version) !== null && _a !== void 0 ? _a : 1);
-    };
-    GameLocalAPI.prototype.getGameOptions = function (arg) {
-        if (arg === void 0) { arg = 2; }
-        var options = typeof arg === 'object' ? arg : { players: typeof arg === 'number' ? arg : 2 };
+        const [state, players] = this.tutorial.setupTutorial();
+        return this.initGameStore(state, players, this.tutorial.version ?? 1);
+    }
+    getGameOptions(arg = 2) {
+        const options = typeof arg === 'object' ? arg : { players: typeof arg === 'number' ? arg : 2 };
         if (typeof options.players !== 'number' && !Array.isArray(options.players))
             options.players = 2;
-        if (this.optionsSpec && (0, rules_api_1.isWithPlayerOptions)(this.optionsSpec)) {
+        if (this.optionsSpec && isWithPlayerOptions(this.optionsSpec)) {
             if (typeof options.players === 'number') {
-                options.players = __spreadArray([], Array(options.players), true).map(function () { return ({}); });
+                options.players = [...Array(options.players)].map(() => ({}));
             }
             else {
-                for (var i = 0; i < options.players.length; i++) {
+                for (let i = 0; i < options.players.length; i++) {
                     if (typeof options.players[i] !== 'object')
                         options.players[i] = {};
                 }
             }
-            var _loop_3 = function (option) {
-                var playerOptionValue = this_1.optionsSpec.players[option];
-                var optionValues = (0, rules_api_1.generatePlayersOption)(options.players.map(function (p) { var _a; return (_a = p[option]) !== null && _a !== void 0 ? _a : null; }), playerOptionValue);
-                for (var i = 0; i < options.players.length; i++) {
+            for (const option in this.optionsSpec.players) {
+                const playerOptionValue = this.optionsSpec.players[option];
+                const optionValues = generatePlayersOption(options.players.map((p) => p[option] ?? null), playerOptionValue);
+                for (let i = 0; i < options.players.length; i++) {
                     options.players[i][option] = optionValues[i];
                 }
-            };
-            var this_1 = this;
-            for (var option in this.optionsSpec.players) {
-                _loop_3(option);
             }
         }
         return options;
-    };
-    GameLocalAPI.prototype.newGame = function (arg) {
-        if (arg === void 0) { arg = 2; }
-        var options = this.getGameOptions(arg);
-        var playerIds = this.optionsSpec && (0, rules_api_1.isWithPlayerIdOptions)(this.optionsSpec) ?
-            options.players.map(function (player) { return player.id; })
-            : (Array.isArray(options.players) ? options.players : __spreadArray([], Array(options.players), true)).map(function (_, index) { return index + 1; });
-        var players = playerIds.map(function (id) { return ({ id: id }); });
+    }
+    newGame(arg = 2) {
+        const options = this.getGameOptions(arg);
+        const playerIds = this.optionsSpec && isWithPlayerIdOptions(this.optionsSpec) ?
+            options.players.map((player) => player.id)
+            : (Array.isArray(options.players) ? options.players : [...Array(options.players)]).map((_, index) => index + 1);
+        const players = playerIds.map(id => ({ id }));
         return this.initGameStore(this.gameSetup.setup(options), players);
-    };
-    GameLocalAPI.prototype.initGameStore = function (game, players, tutorial) {
-        var rules = new this.Rules(game);
-        var playerId = players[0].id;
-        (0, rules_api_1.applyAutomaticMoves)(rules);
-        var setup = JSON.parse(JSON.stringify(rules.game));
-        var localStore = { players: players, setup: setup, state: rules.game, actions: [], playerId: playerId, monkeyOpponents: !!tutorial, tutorial: tutorial };
+    }
+    initGameStore(game, players, tutorial) {
+        const rules = new this.Rules(game);
+        const playerId = players[0].id;
+        applyAutomaticMoves(rules);
+        const setup = JSON.parse(JSON.stringify(rules.game));
+        const localStore = { players, setup, state: rules.game, actions: [], playerId, monkeyOpponents: !!tutorial, tutorial };
         localStorage.setItem(this.storage, JSON.stringify(localStore));
         return localStore;
-    };
-    GameLocalAPI.prototype.getLocalStore = function () {
+    }
+    getLocalStore() {
         return JSON.parse(localStorage.getItem(this.storage));
-    };
-    GameLocalAPI.prototype.play = function (move) {
-        var _this = this;
-        return mimicDataTransfer(move).then(function (move) {
-            var _a;
-            var localStore = _this.getLocalStore();
-            var rules = new _this.Rules(localStore.state);
-            if (!verifyNonMutation(function () { return rules.isLegalMove(localStore.playerId, move); }, function () { return rules.game; }, 'isLegalMove and getLegalMoves must not change the game state')) {
+    }
+    play(move) {
+        return mimicDataTransfer(move).then(move => {
+            const localStore = this.getLocalStore();
+            const rules = new this.Rules(localStore.state);
+            if (!verifyNonMutation(() => rules.isLegalMove(localStore.playerId, move), () => rules.game, 'isLegalMove and getLegalMoves must not change the game state')) {
                 console.error('This move is not authorized right now: ' + JSON.stringify(move));
-                if (_this.tutorial) {
-                    (_a = _this.dispatch) === null || _a === void 0 ? void 0 : _a.call(_this, (0, Actions_1.actionFailed)(Failure_1.Failure.TUTORIAL_MOVE_EXPECTED));
+                if (this.tutorial) {
+                    this.dispatch?.(reportFailure(Failure.TUTORIAL_MOVE_EXPECTED));
                 }
                 if (rules.getLegalMoves) {
                     console.info('Legal moves are:', rules.getLegalMoves(localStore.playerId));
                 }
                 return;
             }
-            _this.autoPlayersCounter = 0;
-            _this.playActions(localStore.playerId, [move]);
-        }).catch(function (error) {
+            this.autoPlayersCounter = 0;
+            this.playActions(localStore.playerId, [move]);
+        }).catch(error => {
             console.error('The move could not be applied due to this error:', error);
             throw error;
         });
-    };
-    GameLocalAPI.prototype.playActions = function (playerId, moves) {
-        var _a;
-        var _this = this;
-        var _b, _c;
-        var localStore = this.getLocalStore();
-        var game = new this.Rules(localStore.state);
-        var actions = [];
-        var notifications = [];
-        if ((0, rules_api_1.hasHiddenInformation)(game)) {
-            for (var _i = 0, moves_1 = moves; _i < moves_1.length; _i++) {
-                var move = moves_1[_i];
-                var recipients = (0, rules_api_1.hasSecretInformation)(game) && game.getPlayerMoveView ? localStore.players.map(function (player) { return player.id; }) : [];
-                var id = (++this.lastActionId).toString();
-                var _d = (0, rules_api_1.playActionWithViews)(game, move, playerId, recipients, id), action = _d.action, views = _d.views;
-                if ((0, rules_api_1.hasSecretInformation)(game) && game.keepMoveSecret) {
-                    var _loop_4 = function (secretAction) {
-                        var secretToPlayer = secretAction.secrets.find(function (secret) { return secret.recipient === localStore.playerId; });
+    }
+    playActions(playerId, moves) {
+        const localStore = this.getLocalStore();
+        const game = new this.Rules(localStore.state);
+        const actions = [];
+        const notifications = [];
+        if (hasHiddenInformation(game)) {
+            for (const move of moves) {
+                const recipients = hasSecretInformation(game) && game.getPlayerMoveView ? localStore.players.map(player => player.id) : [];
+                const id = (++this.lastActionId).toString();
+                const { action, views } = playActionWithViews(game, move, playerId, recipients, id);
+                if (hasSecretInformation(game) && game.keepMoveSecret) {
+                    for (const secretAction of localStore.actions.filter(isSecretAction)) {
+                        const secretToPlayer = secretAction.secrets.find(secret => secret.recipient === localStore.playerId);
                         if (secretToPlayer && !game.keepMoveSecret(secretAction.move, localStore.playerId)) {
-                            notifications.push((0, Types_1.movePlayedNotification)(secretToPlayer.action));
+                            notifications.push(movePlayedNotification(secretToPlayer.action));
                         }
-                        secretAction.secrets = secretAction.secrets.filter(function (secret) { return secret.recipient === undefined || game.keepMoveSecret(secretAction.move, secret.recipient); });
+                        secretAction.secrets = secretAction.secrets.filter(secret => secret.recipient === undefined || game.keepMoveSecret(secretAction.move, secret.recipient));
                         if (secretAction.secrets.length === 1) {
                             delete secretAction.secrets;
                         }
-                    };
-                    for (var _e = 0, _f = localStore.actions.filter(rules_api_1.isSecretAction); _e < _f.length; _e++) {
-                        var secretAction = _f[_e];
-                        _loop_4(secretAction);
                     }
-                    var secrets = [];
-                    var _loop_5 = function (player) {
-                        var view = (_b = views.find(function (view) { return view.recipient === player.id; })) !== null && _b !== void 0 ? _b : views.find(function (view) { return !view.recipient; });
+                    const secrets = [];
+                    for (const player of localStore.players) {
+                        const view = views.find(view => view.recipient === player.id) ?? views.find(view => !view.recipient);
                         if (player.id !== playerId && game.keepMoveSecret(move, player.id)) {
                             secrets.push({ recipient: player.id, action: view.action });
                         }
                         else if (player.id === localStore.playerId) {
-                            notifications.push((0, Types_1.movePlayedNotification)(view.action));
+                            notifications.push(movePlayedNotification(view.action));
                         }
-                    };
-                    for (var _g = 0, _h = localStore.players; _g < _h.length; _g++) {
-                        var player = _h[_g];
-                        _loop_5(player);
                     }
-                    var spectatorView = views.find(function (view) { return view.recipient === undefined; });
+                    const spectatorView = views.find(view => view.recipient === undefined);
                     if (secrets.length) {
                         action.secrets = secrets;
                         secrets.push(spectatorView);
                     }
                     else if (localStore.playerId === undefined) {
-                        notifications.push((0, Types_1.movePlayedNotification)(spectatorView.action));
+                        notifications.push(movePlayedNotification(spectatorView.action));
                     }
                 }
                 else {
-                    var view = (_c = views.find(function (view) { return view.recipient === localStore.playerId; })) !== null && _c !== void 0 ? _c : views.find(function (view) { return !view.recipient; });
-                    notifications.push((0, Types_1.movePlayedNotification)(view.action));
+                    const view = views.find(view => view.recipient === localStore.playerId) ?? views.find(view => !view.recipient);
+                    notifications.push(movePlayedNotification(view.action));
                 }
                 actions.push(action);
             }
         }
         else {
-            for (var _j = 0, moves_2 = moves; _j < moves_2.length; _j++) {
-                var move = moves_2[_j];
-                var id = (++this.lastActionId).toString();
-                var action = (0, rules_api_1.playAction)(game, move, playerId);
+            for (const move of moves) {
+                const id = (++this.lastActionId).toString();
+                const action = playAction(game, move, playerId);
                 action.id = id;
                 actions.push(action);
-                notifications.push((0, Types_1.movePlayedNotification)(action));
+                notifications.push(movePlayedNotification(action));
             }
         }
-        var index = this.incrementNotificationsCount(notifications.length);
-        mimicDataTransfer({ notifications: notifications, index: index }, { sizeWarn: 9000 }).then(function (data) {
-            return _this.dispatch((0, Actions_1.gameNotificationsReceived)(data.notifications, data.index, localStore.players));
-        });
-        (_a = localStore.actions).push.apply(_a, actions);
+        const index = this.incrementNotificationsCount(notifications.length);
+        mimicDataTransfer({ notifications, index }, { sizeWarn: 9000 }).then(data => this.dispatch(receiveNotifications({
+            notifications: data.notifications,
+            notificationsIndex: data.index,
+            players: localStore.players,
+            serverTime: undefined
+        })));
+        localStore.actions.push(...actions);
         localStorage.setItem(this.storage, JSON.stringify(localStore));
-        setTimeout(function () { return _this.runAutoPlayers(); }, 100 + Math.random() * 100);
-    };
-    GameLocalAPI.prototype.incrementNotificationsCount = function (quantity) {
-        if (quantity === void 0) { quantity = 1; }
-        var previousValue = this.notificationsCount;
+        setTimeout(() => this.runAutoPlayers(), 100 + Math.random() * 100);
+    }
+    incrementNotificationsCount(quantity = 1) {
+        const previousValue = this.notificationsCount;
         this.notificationsCount += quantity;
         return previousValue;
-    };
-    GameLocalAPI.prototype.undo = function (arg, ignoreRules) {
-        var _this = this;
-        if (arg === void 0) { arg = 1; }
+    }
+    undo(arg = 1, ignoreRules) {
         if (typeof arg === 'string') {
-            mimicDataTransfer(arg).then(function (actionId) {
-                var localStore = _this.getLocalStore();
-                var index = (0, ArrayUtil_1.findLastIndex)(localStore.actions, function (action) { return action.id === actionId; });
+            mimicDataTransfer(arg).then(actionId => {
+                const localStore = this.getLocalStore();
+                const index = findLastIndex(localStore.actions, action => action.id === actionId);
                 if (index === -1)
                     return;
-                var action = localStore.actions[index];
+                const action = localStore.actions[index];
                 if (!ignoreRules) {
-                    var game = new _this.Rules(localStore.state);
-                    if (!(0, rules_api_1.hasUndo)(game))
+                    const game = new this.Rules(localStore.state);
+                    if (!hasUndo(game))
                         return console.error('This game does not have UNDO feature');
                     if (!game.canUndo(action, localStore.actions.slice(index + 1)))
                         return console.error('Trying to UNDO a move while it is forbidden');
                 }
                 localStore.actions.splice(index, 1);
-                var rules = new _this.Rules(JSON.parse(JSON.stringify(localStore.setup)));
-                (0, rules_api_1.replayActions)(rules, localStore.actions);
+                const rules = new this.Rules(JSON.parse(JSON.stringify(localStore.setup)));
+                replayActions(rules, localStore.actions);
                 localStore.state = rules.game;
-                localStorage.setItem(_this.storage, JSON.stringify(localStore));
-                if (!(0, rules_api_1.isSecretAction)(action) || !action.secrets.some(function (secret) { return secret.recipient === localStore.playerId; })) {
-                    mimicDataTransfer({ notification: (0, Types_1.moveUndoneNotification)(action, index), index: _this.incrementNotificationsCount() }).then(function (data) {
-                        return _this.dispatch((0, Actions_1.gameNotificationsReceived)([data.notification], data.index, localStore.players));
-                    });
+                localStorage.setItem(this.storage, JSON.stringify(localStore));
+                if (!isSecretAction(action) || !action.secrets.some(secret => secret.recipient === localStore.playerId)) {
+                    mimicDataTransfer({ notification: moveUndoneNotification(action, index), index: this.incrementNotificationsCount() }).then(data => this.dispatch(receiveNotifications({
+                        notifications: [data.notification],
+                        notificationsIndex: data.index,
+                        players: localStore.players,
+                        serverTime: undefined
+                    })));
                 }
             });
         }
         else if (arg > 0) {
-            var actions = this.getLocalStore().actions;
+            const actions = this.getLocalStore().actions;
             if (!actions.length)
                 return console.warn('Cannot undo, no actions were played yet');
-            for (var i = actions.length - 1; i > actions.length - 1 - arg; i--) {
+            for (let i = actions.length - 1; i > actions.length - 1 - arg; i--) {
                 this.undo(actions[i].id, true);
             }
         }
-    };
-    GameLocalAPI.prototype.startBots = function () {
-        var localStore = this.getLocalStore();
+    }
+    startBots() {
+        const localStore = this.getLocalStore();
         localStore.monkeyOpponents = true;
         localStorage.setItem(this.storage, JSON.stringify(localStore));
         this.autoPlayersCounter = 0;
         this.runAutoPlayers();
-    };
-    GameLocalAPI.prototype.stopBots = function () {
-        var localStore = this.getLocalStore();
+    }
+    stopBots() {
+        const localStore = this.getLocalStore();
         localStore.monkeyOpponents = false;
         localStorage.setItem(this.storage, JSON.stringify(localStore));
-    };
-    GameLocalAPI.prototype.runAutoPlayers = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var localStore, rules, nextExpectedMove, expectedMoves, expectedMove_1, player, player, moves;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (this.autoPlayersCounter > 100) {
-                            console.warn('The automatic players played 100 times. There might be an infinite loop, stopping now.');
-                            return [2];
-                        }
-                        localStore = this.getLocalStore();
-                        rules = new this.Rules(localStore.state);
-                        if (rules.isOver(localStore.players.map(function (player) { return player.id; }))) {
-                            console.info('Game is over');
-                            (_a = this.dispatch) === null || _a === void 0 ? void 0 : _a.call(this, (0, Actions_1.gameOver)([]));
-                            return [2];
-                        }
-                        if (localStore.tutorial && this.tutorial) {
-                            if (!this.tutorialMovesToPlay)
-                                return [2];
-                            nextExpectedMove = this.tutorial.getNextMove(rules, localStore.actions.length);
-                            if (nextExpectedMove) {
-                                expectedMoves = Array.isArray(nextExpectedMove) ? nextExpectedMove : [nextExpectedMove];
-                                if (expectedMoves.some(function (expectedMove) { return rules.isLegalMove(localStore.playerId, expectedMove); })) {
-                                    if (this.tutorialMovesToPlay !== Infinity) {
-                                        this.tutorialMovesToPlay = 0;
-                                    }
-                                    return [2];
-                                }
-                                expectedMove_1 = expectedMoves[0];
-                                player = localStore.players.find(function (player) { return rules.isLegalMove(player.id, expectedMove_1); });
-                                if (player) {
-                                    this.tutorialMovesToPlay--;
-                                    return [2, this.playActions(player.id, [expectedMove_1])];
-                                }
-                                else {
-                                    console.error('Tutorial expects a move that no player can play: ', expectedMove_1);
-                                }
-                            }
-                        }
-                        if (!(localStore.monkeyOpponents && !this.aiProcessing)) return [3, 3];
-                        player = localStore.players.find(function (player) { return player.id !== localStore.playerId && rules.isTurnToPlay(player.id); });
-                        if (!player) return [3, 2];
-                        this.aiProcessing = true;
-                        return [4, this.getAI(player.id)(rules.game, player.id)];
-                    case 1:
-                        moves = _b.sent();
-                        this.aiProcessing = false;
-                        if (moves.length) {
-                            this.playActions(player.id, moves);
-                            this.autoPlayersCounter++;
-                        }
-                        else {
-                            console.error("Player ".concat(player.id, " is active but did not return any move to play!"));
-                        }
-                        return [3, 3];
-                    case 2:
-                        if (localStore.playerId === undefined || !rules.isTurnToPlay(localStore.playerId)) {
-                            console.error('Game is not over but there is no active player!');
-                        }
-                        _b.label = 3;
-                    case 3: return [2];
+    }
+    async runAutoPlayers() {
+        if (this.autoPlayersCounter > 100) {
+            console.warn('The automatic players played 100 times. There might be an infinite loop, stopping now.');
+            return;
+        }
+        const localStore = this.getLocalStore();
+        const rules = new this.Rules(localStore.state);
+        if (rules.isOver(localStore.players.map(player => player.id))) {
+            console.info('Game is over');
+            this.dispatch?.(setGameOver([]));
+            return;
+        }
+        if (localStore.tutorial && this.tutorial) {
+            if (!this.tutorialMovesToPlay)
+                return;
+            const nextExpectedMove = this.tutorial.getNextMove(rules, localStore.actions.length);
+            if (nextExpectedMove) {
+                const expectedMoves = Array.isArray(nextExpectedMove) ? nextExpectedMove : [nextExpectedMove];
+                if (expectedMoves.some(expectedMove => rules.isLegalMove(localStore.playerId, expectedMove))) {
+                    if (this.tutorialMovesToPlay !== Infinity) {
+                        this.tutorialMovesToPlay = 0;
+                    }
+                    return;
                 }
-            });
-        });
-    };
-    GameLocalAPI.prototype.getAI = function (playerId) {
+                const expectedMove = expectedMoves[0];
+                const player = localStore.players.find(player => rules.isLegalMove(player.id, expectedMove));
+                if (player) {
+                    this.tutorialMovesToPlay--;
+                    return this.playActions(player.id, [expectedMove]);
+                }
+                else {
+                    console.error('Tutorial expects a move that no player can play: ', expectedMove);
+                }
+            }
+        }
+        if (localStore.monkeyOpponents && !this.aiProcessing) {
+            const player = localStore.players.find(player => player.id !== localStore.playerId && rules.isTurnToPlay(player.id));
+            if (player) {
+                this.aiProcessing = true;
+                const moves = await this.getAI(player.id)(rules.game, player.id);
+                this.aiProcessing = false;
+                if (moves.length) {
+                    this.playActions(player.id, moves);
+                    this.autoPlayersCounter++;
+                }
+                else {
+                    console.error(`Player ${player.id} is active but did not return any move to play!`);
+                }
+            }
+            else if (localStore.playerId === undefined || !rules.isTurnToPlay(localStore.playerId)) {
+                console.error('Game is not over but there is no active player!');
+            }
+        }
+    }
+    getAI(playerId) {
         if (this.ai)
             return this.ai;
-        var bot = new rules_api_1.RandomBot(this.Rules, playerId);
-        return function (game) { return Promise.resolve(bot.run(game)); };
-    };
-    GameLocalAPI.prototype.setPlayerName = function (name, playerId) {
-        var localStore = this.getLocalStore();
-        var player = localStore.players.find(function (player) { return player.id === (playerId || localStore.playerId); });
+        const bot = new RandomBot(this.Rules, playerId);
+        return (game) => Promise.resolve(bot.run(game));
+    }
+    setPlayerName(name, playerId) {
+        const localStore = this.getLocalStore();
+        const player = localStore.players.find(player => player.id === (playerId || localStore.playerId));
         if (!player) {
             throw new Error('Player not found');
         }
         player.name = name;
         localStorage.setItem(this.storage, JSON.stringify(localStore));
-    };
-    GameLocalAPI.prototype.setAnimationsSpeed = function (speed) {
-        if (speed === void 0) { speed = 1; }
-        this.dispatch((0, Actions_1.setAnimationsSpeed)(speed));
+    }
+    setAnimationsSpeed(speed = 1) {
+        this.dispatch(setAnimationsSpeed(speed));
         localStorage.setItem('animationsSpeed', speed.toString());
-    };
-    GameLocalAPI.prototype.eject = function () {
-    };
-    GameLocalAPI.prototype.giveUp = function () {
-    };
-    GameLocalAPI.prototype.playTutorialMoves = function (quantity) {
-        var _this = this;
+    }
+    eject() {
+    }
+    giveUp() {
+    }
+    playTutorialMoves(quantity) {
         if (quantity) {
             this.tutorialMovesToPlay += quantity;
             this.autoPlayersCounter = 0;
-            setTimeout(function () { return _this.runAutoPlayers(); }, 100 + Math.random() * 100);
+            setTimeout(() => this.runAutoPlayers(), 100 + Math.random() * 100);
         }
         else {
             this.tutorialMovesToPlay = 0;
         }
-    };
-    return GameLocalAPI;
-}());
-exports.GameLocalAPI = GameLocalAPI;
-function mimicDataTransfer(data, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.sizeWarn, sizeWarn = _a === void 0 ? 0 : _a, _b = options.duration, duration = _b === void 0 ? 100 : _b;
-    var stringData = JSON.stringify(data !== null && data !== void 0 ? data : null);
+    }
+}
+function mimicDataTransfer(data, options = {}) {
+    const { sizeWarn = 0, duration = 100 } = options;
+    const stringData = JSON.stringify(data ?? null);
     data = JSON.parse(stringData);
     if (sizeWarn && stringData) {
         if (stringData.length > sizeWarn) {
-            console.warn("Notification payload of ".concat(stringData.length, " bytes exceeds ").concat(sizeWarn, " bytes, which can cause extra http requests."), stringData);
+            console.warn(`Notification payload of ${stringData.length} bytes exceeds ${sizeWarn} bytes, which can cause extra http requests.`, stringData);
         }
     }
-    return new Promise(function (resolve) { return setTimeout(function () { return resolve(data); }, duration); });
+    return new Promise(resolve => setTimeout(() => resolve(data), duration));
 }
 function verifyNonMutation(operation, getState, message) {
-    var initialState = JSON.stringify(getState());
-    var result = operation();
-    var finalState = JSON.stringify(getState());
-    (0, assert_1.default)(initialState === finalState, message);
+    const initialState = JSON.stringify(getState());
+    const result = operation();
+    const finalState = JSON.stringify(getState());
+    assert(initialState === finalState, message);
     return result;
 }
 function sortObjectKeys(value) {
     if (typeof value !== 'object' || value === null)
         return value;
-    return Object.keys(value).sort().reduce(function (obj, key) {
+    return Object.keys(value).sort().reduce((obj, key) => {
         obj[key] = value[key];
         return obj;
     }, {});