@mnbroatch/boardgame.io 0.0.1

package/dist/esm/client-5f57c3f2.js

@@ -0,0 +1,255 @@
+const assertString = (str, label) => {
+    if (!str || typeof str !== 'string') {
+        throw new Error(`Expected ${label} string, got "${str}".`);
+    }
+};
+const assertGameName = (name) => assertString(name, 'game name');
+const assertMatchID = (id) => assertString(id, 'match ID');
+const validateBody = (body, schema) => {
+    if (!body)
+        throw new Error(`Expected body, got “${body}”.`);
+    for (const key in schema) {
+        const propSchema = schema[key];
+        const types = Array.isArray(propSchema) ? propSchema : [propSchema];
+        const received = body[key];
+        if (!types.includes(typeof received)) {
+            const union = types.join('|');
+            throw new TypeError(`Expected body.${key} to be of type ${union}, got “${received}”.`);
+        }
+    }
+};
+class LobbyClientError extends Error {
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+    }
+}
+/**
+ * Create a boardgame.io Lobby API client.
+ * @param server The API’s base URL, e.g. `http://localhost:8000`.
+ */
+class LobbyClient {
+    constructor({ server = '' } = {}) {
+        // strip trailing slash if passed
+        this.server = server.replace(/\/$/, '');
+    }
+    async request(route, init) {
+        const response = await fetch(this.server + route, init);
+        if (!response.ok) {
+            let details;
+            try {
+                details = await response.clone().json();
+            }
+            catch {
+                try {
+                    details = await response.text();
+                }
+                catch (error) {
+                    details = error.message;
+                }
+            }
+            throw new LobbyClientError(`HTTP status ${response.status}`, details);
+        }
+        return response.json();
+    }
+    async post(route, opts) {
+        let init = {
+            method: 'post',
+            body: JSON.stringify(opts.body),
+            headers: { 'Content-Type': 'application/json' },
+        };
+        if (opts.init)
+            init = {
+                ...init,
+                ...opts.init,
+                headers: { ...init.headers, ...opts.init.headers },
+            };
+        return this.request(route, init);
+    }
+    /**
+     * Get a list of the game names available on this server.
+     * @param  init Optional RequestInit interface to override defaults.
+     * @return Array of game names.
+     *
+     * @example
+     * lobbyClient.listGames()
+     *   .then(console.log); // => ['chess', 'tic-tac-toe']
+     */
+    async listGames(init) {
+        return this.request('/games', init);
+    }
+    /**
+     * Get a list of the matches for a specific game type on the server.
+     * @param  gameName The game to list for, e.g. 'tic-tac-toe'.
+     * @param  where    Options to filter matches by update time or gameover state
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Array of match metadata objects.
+     *
+     * @example
+     * lobbyClient.listMatches('tic-tac-toe', where: { isGameover: false })
+     *   .then(data => console.log(data.matches));
+     * // => [
+     * //   {
+     * //     matchID: 'xyz',
+     * //     gameName: 'tic-tac-toe',
+     * //     players: [{ id: 0, name: 'Alice' }, { id: 1 }]
+     * //   },
+     * //   ...
+     * // ]
+     */
+    async listMatches(gameName, where, init) {
+        assertGameName(gameName);
+        let query = '';
+        if (where) {
+            const queries = [];
+            const { isGameover, updatedBefore, updatedAfter } = where;
+            if (isGameover !== undefined)
+                queries.push(`isGameover=${isGameover}`);
+            if (updatedBefore)
+                queries.push(`updatedBefore=${updatedBefore}`);
+            if (updatedAfter)
+                queries.push(`updatedAfter=${updatedAfter}`);
+            if (queries.length > 0)
+                query = '?' + queries.join('&');
+        }
+        return this.request(`/games/${gameName}${query}`, init);
+    }
+    /**
+     * Get metadata for a specific match.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to fetch.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return A match metadata object.
+     *
+     * @example
+     * lobbyClient.getMatch('tic-tac-toe', 'xyz').then(console.log);
+     * // => {
+     * //   matchID: 'xyz',
+     * //   gameName: 'tic-tac-toe',
+     * //   players: [{ id: 0, name: 'Alice' }, { id: 1 }]
+     * // }
+     */
+    async getMatch(gameName, matchID, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        return this.request(`/games/${gameName}/${matchID}`, init);
+    }
+    /**
+     * Create a new match for a specific game type.
+     * @param  gameName The game to create a match for, e.g. 'tic-tac-toe'.
+     * @param  body     Options required to configure match creation.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return An object containing the created `matchID`.
+     *
+     * @example
+     * lobbyClient.createMatch('tic-tac-toe', { numPlayers: 2 })
+     *   .then(console.log);
+     * // => { matchID: 'xyz' }
+     */
+    async createMatch(gameName, body, init) {
+        assertGameName(gameName);
+        validateBody(body, { numPlayers: 'number' });
+        return this.post(`/games/${gameName}/create`, { body, init });
+    }
+    /**
+     * Join a match using its matchID.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to join.
+     * @param  body     Options required to join match.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Object containing `playerCredentials` for the player who joined.
+     *
+     * @example
+     * lobbyClient.joinMatch('tic-tac-toe', 'xyz', {
+     *   playerID: '1',
+     *   playerName: 'Bob',
+     * }).then(console.log);
+     * // => { playerID: '1', playerCredentials: 'random-string' }
+     */
+    async joinMatch(gameName, matchID, body, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        validateBody(body, {
+            playerID: ['string', 'undefined'],
+            playerName: 'string',
+        });
+        return this.post(`/games/${gameName}/${matchID}/join`, { body, init });
+    }
+    /**
+     * Leave a previously joined match.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to leave.
+     * @param  body     Options required to leave match.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Promise resolves if successful.
+     *
+     * @example
+     * lobbyClient.leaveMatch('tic-tac-toe', 'xyz', {
+     *   playerID: '1',
+     *   credentials: 'credentials-returned-when-joining',
+     * })
+     *   .then(() => console.log('Left match.'))
+     *   .catch(error => console.error('Error leaving match', error));
+     */
+    async leaveMatch(gameName, matchID, body, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        validateBody(body, { playerID: 'string', credentials: 'string' });
+        await this.post(`/games/${gameName}/${matchID}/leave`, { body, init });
+    }
+    /**
+     * Update a player’s name or custom metadata.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to update.
+     * @param  body     Options required to update player.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Promise resolves if successful.
+     *
+     * @example
+     * lobbyClient.updatePlayer('tic-tac-toe', 'xyz', {
+     *   playerID: '0',
+     *   credentials: 'credentials-returned-when-joining',
+     *   newName: 'Al',
+     * })
+     *   .then(() => console.log('Updated player data.'))
+     *   .catch(error => console.error('Error updating data', error));
+     */
+    async updatePlayer(gameName, matchID, body, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        validateBody(body, { playerID: 'string', credentials: 'string' });
+        await this.post(`/games/${gameName}/${matchID}/update`, { body, init });
+    }
+    /**
+     * Create a new match based on the configuration of the current match.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to play again.
+     * @param  body     Options required to configure match.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Object containing `nextMatchID`.
+     *
+     * @example
+     * lobbyClient.playAgain('tic-tac-toe', 'xyz', {
+     *   playerID: '0',
+     *   credentials: 'credentials-returned-when-joining',
+     * })
+     *   .then(({ nextMatchID }) => {
+     *     return lobbyClient.joinMatch('tic-tac-toe', nextMatchID, {
+     *       playerID: '0',
+     *       playerName: 'Al',
+     *     })
+     *   })
+     *   .then({ playerCredentials } => {
+     *     console.log(playerCredentials);
+     *   })
+     *   .catch(console.error);
+     */
+    async playAgain(gameName, matchID, body, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        validateBody(body, { playerID: 'string', credentials: 'string' });
+        return this.post(`/games/${gameName}/${matchID}/playAgain`, { body, init });
+    }
+}
+
+export { LobbyClient as L, LobbyClientError as a };

package/dist/esm/client.js

@@ -0,0 +1,16 @@
+export { C as Client } from './client-2e653027.js';
+export { L as LobbyClient, a as LobbyClientError } from './client-5f57c3f2.js';
+import 'nanoid/non-secure';
+import './Debug-0141fe2d.js';
+import './turn-order-376d315e.js';
+import 'immer';
+import './plugin-random-087f861e.js';
+import 'lodash.isplainobject';
+import 'flatted';
+import './reducer-c46da7e5.js';
+import 'rfc6902';
+import './ai-5c06e761.js';
+import 'setimmediate';
+import 'redux';
+import './initialize-11d626ca.js';
+import './transport-ce07b771.js';

package/dist/esm/core.js

@@ -0,0 +1,40 @@
+export { C as ActivePlayers, h as GameMethod, w as INVALID_MOVE, k as Stage, T as TurnOrder } from './turn-order-376d315e.js';
+import 'immer';
+import './plugin-random-087f861e.js';
+import 'lodash.isplainobject';
+
+/*
+ * Copyright 2018 The boardgame.io Authors
+ *
+ * Use of this source code is governed by a MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ */
+/**
+ * PlayerView reducers.
+ */
+const PlayerView = {
+    /**
+     * STRIP_SECRETS
+     *
+     * Reducer which removes a key named `secret` and
+     * removes all the keys in `players`, except for the one
+     * corresponding to the current playerID.
+     */
+    STRIP_SECRETS: ({ G, playerID }) => {
+        const r = { ...G };
+        if (r.secret !== undefined) {
+            delete r.secret;
+        }
+        if (r.players) {
+            r.players = playerID
+                ? {
+                    [playerID]: r.players[playerID],
+                }
+                : {};
+        }
+        return r;
+    },
+};
+
+export { PlayerView };

package/dist/esm/debug.js

@@ -0,0 +1,10 @@
+export { D as Debug } from './Debug-0141fe2d.js';
+import './turn-order-376d315e.js';
+import 'immer';
+import './plugin-random-087f861e.js';
+import 'lodash.isplainobject';
+import 'flatted';
+import './reducer-c46da7e5.js';
+import 'rfc6902';
+import './ai-5c06e761.js';
+import 'setimmediate';

package/dist/esm/filter-player-view-2c6cc96f.js

@@ -0,0 +1,87 @@
+import { P as PlayerView } from './turn-order-376d315e.js';
+import { createPatch } from 'rfc6902';
+
+const applyPlayerView = (game, playerID, state) => ({
+    ...state,
+    G: game.playerView({ G: state.G, ctx: state.ctx, playerID }),
+    plugins: PlayerView(state, { playerID, game }),
+    deltalog: undefined,
+    _undo: [],
+    _redo: [],
+});
+/** Gets a function that filters the TransportData for a given player and game. */
+const getFilterPlayerView = (game) => (playerID, payload) => {
+    switch (payload.type) {
+        case 'patch': {
+            const [matchID, stateID, prevState, state] = payload.args;
+            const log = redactLog(state.deltalog, playerID);
+            const filteredState = applyPlayerView(game, playerID, state);
+            const newStateID = state._stateID;
+            const prevFilteredState = applyPlayerView(game, playerID, prevState);
+            const patch = createPatch(prevFilteredState, filteredState);
+            return {
+                type: 'patch',
+                args: [matchID, stateID, newStateID, patch, log],
+            };
+        }
+        case 'update': {
+            const [matchID, state] = payload.args;
+            const log = redactLog(state.deltalog, playerID);
+            const filteredState = applyPlayerView(game, playerID, state);
+            return {
+                type: 'update',
+                args: [matchID, filteredState, log],
+            };
+        }
+        case 'sync': {
+            const [matchID, syncInfo] = payload.args;
+            const filteredState = applyPlayerView(game, playerID, syncInfo.state);
+            const log = redactLog(syncInfo.log, playerID);
+            const newSyncInfo = {
+                ...syncInfo,
+                state: filteredState,
+                log,
+            };
+            return {
+                type: 'sync',
+                args: [matchID, newSyncInfo],
+            };
+        }
+        default: {
+            return payload;
+        }
+    }
+};
+/**
+ * Redact the log.
+ *
+ * @param {Array} log - The game log (or deltalog).
+ * @param {String} playerID - The playerID that this log is
+ *                            to be sent to.
+ */
+function redactLog(log, playerID) {
+    if (log === undefined) {
+        return log;
+    }
+    return log.map((logEvent) => {
+        // filter for all other players and spectators.
+        if (playerID !== null && +playerID === +logEvent.action.payload.playerID) {
+            return logEvent;
+        }
+        if (logEvent.redact !== true) {
+            return logEvent;
+        }
+        const payload = {
+            ...logEvent.action.payload,
+            args: null,
+        };
+        const filteredEvent = {
+            ...logEvent,
+            action: { ...logEvent.action, payload },
+        };
+        const { redact, ...remaining } = filteredEvent;
+        return remaining;
+    });
+}
+
+export { getFilterPlayerView as g };

package/dist/esm/initialize-11d626ca.js

@@ -0,0 +1,59 @@
+import { P as ProcessGameConfig } from './reducer-c46da7e5.js';
+import { z as Setup, E as Enhance, j as GetAPIs, x as FlushAndValidate } from './turn-order-376d315e.js';
+
+/*
+ * Copyright 2020 The boardgame.io Authors
+ *
+ * Use of this source code is governed by a MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ */
+/**
+ * Creates the initial game state.
+ */
+function InitializeGame({ game, numPlayers, setupData, }) {
+    game = ProcessGameConfig(game);
+    if (!numPlayers) {
+        numPlayers = 2;
+    }
+    const ctx = game.flow.ctx(numPlayers);
+    let state = {
+        // User managed state.
+        G: {},
+        // Framework managed state.
+        ctx,
+        // Plugin related state.
+        plugins: {},
+    };
+    // Run plugins over initial state.
+    state = Setup(state, { game });
+    state = Enhance(state, { game, playerID: undefined });
+    const pluginAPIs = GetAPIs(state);
+    state.G = game.setup({ ...pluginAPIs, ctx: state.ctx }, setupData);
+    let initial = {
+        ...state,
+        // List of {G, ctx} pairs that can be undone.
+        _undo: [],
+        // List of {G, ctx} pairs that can be redone.
+        _redo: [],
+        // A monotonically non-decreasing ID to ensure that
+        // state updates are only allowed from clients that
+        // are at the same version that the server.
+        _stateID: 0,
+    };
+    initial = game.flow.init(initial);
+    [initial] = FlushAndValidate(initial, { game });
+    // Initialize undo stack.
+    if (!game.disableUndo) {
+        initial._undo = [
+            {
+                G: initial.G,
+                ctx: initial.ctx,
+                plugins: initial.plugins,
+            },
+        ];
+    }
+    return initial;
+}
+
+export { InitializeGame as I };

package/dist/esm/internal.js

@@ -0,0 +1,10 @@
+export { I as InitializeGame } from './initialize-11d626ca.js';
+export { C as CreateGameReducer, P as ProcessGameConfig } from './reducer-c46da7e5.js';
+export { g as getFilterPlayerView } from './filter-player-view-2c6cc96f.js';
+export { A as Async, S as Sync, c as createMatch } from './util-b6147cef.js';
+export { T as Transport } from './transport-ce07b771.js';
+import './turn-order-376d315e.js';
+import 'immer';
+import './plugin-random-087f861e.js';
+import 'lodash.isplainobject';
+import 'rfc6902';