@mnbroatch/boardgame.io 0.0.1

package/dist/types/src/core/turn-order.d.ts

@@ -0,0 +1,179 @@
+import type { Ctx, ActivePlayersArg, PlayerID, State, TurnConfig, FnContext } from '../types';
+export declare function SetActivePlayers(ctx: Ctx, arg: ActivePlayersArg): Ctx;
+/**
+ * Update activePlayers, setting it to previous, next or null values
+ * when it becomes empty.
+ * @param ctx
+ */
+export declare function UpdateActivePlayersOnceEmpty(ctx: Ctx): {
+    activePlayers: import("../types").ActivePlayers;
+    _activePlayersMinMoves: Record<string, number>;
+    _activePlayersMaxMoves: Record<string, number>;
+    _activePlayersNumMoves: Record<string, number>;
+    _prevActivePlayers: {
+        activePlayers: import("../types").ActivePlayers;
+        _activePlayersMinMoves?: Record<string, number>;
+        _activePlayersMaxMoves?: Record<string, number>;
+        _activePlayersNumMoves?: Record<string, number>;
+    }[];
+    numPlayers: number;
+    playOrder: string[];
+    playOrderPos: number;
+    currentPlayer: string;
+    numMoves?: number;
+    gameover?: any;
+    turn: number;
+    phase: string;
+    _nextActivePlayers?: ActivePlayersArg;
+    _random?: {
+        seed: string | number;
+    };
+};
+/**
+ * Called at the start of a turn to initialize turn order state.
+ *
+ * TODO: This is called inside StartTurn, which is called from
+ * both UpdateTurn and StartPhase (so it's called at the beginning
+ * of a new phase as well as between turns). We should probably
+ * split it into two.
+ */
+export declare function InitTurnOrderState(state: State, turn: TurnConfig): Ctx;
+/**
+ * Called at the end of each turn to update the turn order state.
+ * @param {object} G - The game object G.
+ * @param {object} ctx - The game object ctx.
+ * @param {object} turn - A turn object for this phase.
+ * @param {string} endTurnArg - An optional argument to endTurn that
+                                may specify the next player.
+ */
+export declare function UpdateTurnOrderState(state: State, currentPlayer: PlayerID, turn: TurnConfig, endTurnArg?: true | {
+    remove?: any;
+    next?: string;
+}): {
+    endPhase: boolean;
+    ctx: Ctx;
+};
+/**
+ * Set of different turn orders possible in a phase.
+ * These are meant to be passed to the `turn` setting
+ * in the flow objects.
+ *
+ * Each object defines the first player when the phase / game
+ * begins, and also a function `next` to determine who the
+ * next player is when the turn ends.
+ *
+ * The phase ends if next() returns undefined.
+ */
+export declare const TurnOrder: {
+    /**
+     * DEFAULT
+     *
+     * The default round-robin turn order.
+     */
+    DEFAULT: {
+        first: ({ ctx }: FnContext) => number;
+        next: ({ ctx }: FnContext) => number;
+    };
+    /**
+     * RESET
+     *
+     * Similar to DEFAULT, but starts from 0 each time.
+     */
+    RESET: {
+        first: () => number;
+        next: ({ ctx }: FnContext) => number;
+    };
+    /**
+     * CONTINUE
+     *
+     * Similar to DEFAULT, but starts with the player who ended the last phase.
+     */
+    CONTINUE: {
+        first: ({ ctx }: FnContext) => number;
+        next: ({ ctx }: FnContext) => number;
+    };
+    /**
+     * ONCE
+     *
+     * Another round-robin turn order, but goes around just once.
+     * The phase ends after all players have played.
+     */
+    ONCE: {
+        first: () => number;
+        next: ({ ctx }: FnContext) => number;
+    };
+    /**
+     * CUSTOM
+     *
+     * Identical to DEFAULT, but also sets playOrder at the
+     * beginning of the phase.
+     *
+     * @param {Array} playOrder - The play order.
+     */
+    CUSTOM: (playOrder: string[]) => {
+        playOrder: () => string[];
+        first: () => number;
+        next: ({ ctx }: FnContext) => number;
+    };
+    /**
+     * CUSTOM_FROM
+     *
+     * Identical to DEFAULT, but also sets playOrder at the
+     * beginning of the phase to a value specified by a field
+     * in G.
+     *
+     * @param {string} playOrderField - Field in G.
+     */
+    CUSTOM_FROM: (playOrderField: string) => {
+        playOrder: ({ G }: FnContext) => any;
+        first: () => number;
+        next: ({ ctx }: FnContext) => number;
+    };
+};
+export declare const Stage: {
+    NULL: any;
+};
+export declare const ActivePlayers: {
+    /**
+     * ALL
+     *
+     * The turn stays with one player, but any player can play (in any order)
+     * until the phase ends.
+     */
+    ALL: {
+        all: any;
+    };
+    /**
+     * ALL_ONCE
+     *
+     * The turn stays with one player, but any player can play (once, and in any order).
+     * This is typically used in a phase where you want to elicit a response
+     * from every player in the game.
+     */
+    ALL_ONCE: {
+        all: any;
+        minMoves: number;
+        maxMoves: number;
+    };
+    /**
+     * OTHERS
+     *
+     * The turn stays with one player, and every *other* player can play (in any order)
+     * until the phase ends.
+     */
+    OTHERS: {
+        others: any;
+    };
+    /**
+     * OTHERS_ONCE
+     *
+     * The turn stays with one player, and every *other* player can play (once, and in any order).
+     * This is typically used in a phase where you want to elicit a response
+     * from every *other* player in the game.
+     */
+    OTHERS_ONCE: {
+        others: any;
+        minMoves: number;
+        maxMoves: number;
+    };
+};

package/dist/types/src/core/turn-order.test.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toHaveUndefinedProperties(): R;
+        }
+    }
+}
+export {};

package/dist/types/src/lobby/client.d.ts

@@ -0,0 +1,194 @@
+import type { LobbyAPI } from '../types';
+export declare class LobbyClientError extends Error {
+    readonly details: any;
+    constructor(message: string, details: any);
+}
+/**
+ * Create a boardgame.io Lobby API client.
+ * @param server The API’s base URL, e.g. `http://localhost:8000`.
+ */
+export declare class LobbyClient {
+    private server;
+    constructor({ server }?: {
+        server?: string;
+    });
+    private request;
+    private post;
+    /**
+     * 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']
+     */
+    listGames(init?: RequestInit): Promise<string[]>;
+    /**
+     * 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 }]
+     * //   },
+     * //   ...
+     * // ]
+     */
+    listMatches(gameName: string, where?: {
+        /**
+         * If true, only games that have ended will be returned.
+         * If false, only games that have not yet ended will be returned.
+         * Leave undefined to receive both finished and unfinished games.
+         */
+        isGameover?: boolean;
+        /**
+         * List matches last updated before a specific time.
+         * Value should be a timestamp in milliseconds after January 1, 1970.
+         */
+        updatedBefore?: number;
+        /**
+         * List matches last updated after a specific time.
+         * Value should be a timestamp in milliseconds after January 1, 1970.
+         */
+        updatedAfter?: number;
+    }, init?: RequestInit): Promise<LobbyAPI.MatchList>;
+    /**
+     * 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 }]
+     * // }
+     */
+    getMatch(gameName: string, matchID: string, init?: RequestInit): Promise<LobbyAPI.Match>;
+    /**
+     * 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' }
+     */
+    createMatch(gameName: string, body: {
+        numPlayers: number;
+        setupData?: any;
+        unlisted?: boolean;
+        [key: string]: any;
+    }, init?: RequestInit): Promise<LobbyAPI.CreatedMatch>;
+    /**
+     * 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' }
+     */
+    joinMatch(gameName: string, matchID: string, body: {
+        playerID?: string;
+        playerName: string;
+        data?: any;
+        [key: string]: any;
+    }, init?: RequestInit): Promise<LobbyAPI.JoinedMatch>;
+    /**
+     * 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));
+     */
+    leaveMatch(gameName: string, matchID: string, body: {
+        playerID: string;
+        credentials: string;
+        [key: string]: any;
+    }, init?: RequestInit): Promise<void>;
+    /**
+     * 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));
+     */
+    updatePlayer(gameName: string, matchID: string, body: {
+        playerID: string;
+        credentials: string;
+        newName?: string;
+        data?: any;
+        [key: string]: any;
+    }, init?: RequestInit): Promise<void>;
+    /**
+     * 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);
+     */
+    playAgain(gameName: string, matchID: string, body: {
+        playerID: string;
+        credentials: string;
+        unlisted?: boolean;
+        [key: string]: any;
+    }, init?: RequestInit): Promise<LobbyAPI.NextMatch>;
+}

package/dist/types/src/lobby/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/lobby/connection.d.ts

@@ -0,0 +1,44 @@
+import type { ComponentType } from 'react';
+import { LobbyClient } from './client';
+import type { Game, LobbyAPI } from '../types';
+export interface GameComponent {
+    game: Game;
+    board: ComponentType<any>;
+}
+interface LobbyConnectionOpts {
+    server: string;
+    playerName?: string;
+    playerCredentials?: string;
+    gameComponents: GameComponent[];
+}
+declare class _LobbyConnectionImpl {
+    client: LobbyClient;
+    gameComponents: GameComponent[];
+    playerName: string;
+    playerCredentials?: string;
+    matches: LobbyAPI.MatchList['matches'];
+    constructor({ server, gameComponents, playerName, playerCredentials, }: LobbyConnectionOpts);
+    refresh(): Promise<void>;
+    _getMatchInstance(matchID: string): LobbyAPI.Match;
+    _getGameComponents(gameName: string): GameComponent;
+    _findPlayer(playerName: string): LobbyAPI.Match;
+    join(gameName: string, matchID: string, playerID: string): Promise<void>;
+    leave(gameName: string, matchID: string): Promise<void>;
+    disconnect(): Promise<void>;
+    create(gameName: string, numPlayers: number): Promise<void>;
+}
+/**
+ * LobbyConnection
+ *
+ * Lobby model.
+ *
+ * @param {string}   server - '<host>:<port>' of the server.
+ * @param {Array}    gameComponents - A map of Board and Game objects for the supported games.
+ * @param {string}   playerName - The name of the player.
+ * @param {string}   playerCredentials - The credentials currently used by the player, if any.
+ *
+ * Returns:
+ *   A JS object that synchronizes the list of running game instances with the server and provides an API to create/join/start instances.
+ */
+export declare function LobbyConnection(opts: LobbyConnectionOpts): _LobbyConnectionImpl;
+export {};

package/dist/types/src/lobby/connection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/lobby/create-match-form.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { Game } from '../types';
+import type { GameComponent } from './connection';
+declare type CreateMatchProps = {
+    games: GameComponent[];
+    createMatch: (gameName: string, numPlayers: number) => Promise<void>;
+};
+declare type CreateMatchState = {
+    selectedGame: number;
+    numPlayers: number;
+};
+declare class LobbyCreateMatchForm extends React.Component<CreateMatchProps, CreateMatchState> {
+    state: {
+        selectedGame: number;
+        numPlayers: number;
+    };
+    constructor(props: CreateMatchProps);
+    _createGameNameOption: (game: GameComponent, idx: number) => JSX.Element;
+    _createNumPlayersOption: (idx: number) => JSX.Element;
+    _createNumPlayersRange: (game: Game) => number[];
+    render(): JSX.Element;
+    onChangeNumPlayers: (event: React.ChangeEvent<HTMLSelectElement>) => void;
+    onChangeSelectedGame: (event: React.ChangeEvent<HTMLSelectElement>) => void;
+    onClickCreate: () => void;
+}
+export default LobbyCreateMatchForm;

package/dist/types/src/lobby/login-form.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+declare type LoginFormProps = {
+    playerName?: string;
+    onEnter: (playerName: string) => void;
+};
+declare type LoginFormState = {
+    playerName?: string;
+    nameErrorMsg: string;
+};
+declare class LobbyLoginForm extends React.Component<LoginFormProps, LoginFormState> {
+    static defaultProps: {
+        playerName: string;
+    };
+    state: {
+        playerName: string;
+        nameErrorMsg: string;
+    };
+    render(): JSX.Element;
+    onClickEnter: () => void;
+    onKeyPress: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    onChangePlayerName: (event: React.ChangeEvent<HTMLInputElement>) => void;
+}
+export default LobbyLoginForm;

package/dist/types/src/lobby/match-instance.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import type { LobbyAPI } from '../types';
+export declare type MatchOpts = {
+    numPlayers: number;
+    matchID: string;
+    playerID?: string;
+};
+declare type Match = {
+    gameName: string;
+    matchID: string;
+    players: LobbyAPI.Match['players'];
+};
+declare type MatchInstanceProps = {
+    match: Match;
+    playerName: string;
+    onClickJoin: (gameName: string, matchID: string, playerID: string) => void;
+    onClickLeave: (gameName: string, matchID: string) => void;
+    onClickPlay: (gameName: string, matchOpts: MatchOpts) => void;
+};
+declare class LobbyMatchInstance extends React.Component<MatchInstanceProps> {
+    _createSeat: (player: {
+        name?: string;
+    }) => string;
+    _createButtonJoin: (inst: Match, seatId: number) => JSX.Element;
+    _createButtonLeave: (inst: Match) => JSX.Element;
+    _createButtonPlay: (inst: Match, seatId: number) => JSX.Element;
+    _createButtonSpectate: (inst: Match) => JSX.Element;
+    _createInstanceButtons: (inst: Match) => JSX.Element;
+    render(): JSX.Element;
+}
+export default LobbyMatchInstance;

package/dist/types/src/lobby/react.d.ts

@@ -0,0 +1,113 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import type { DebugOpt } from '../client/client';
+import { Client } from '../client/react';
+import type { GameComponent } from './connection';
+import type { MatchOpts } from './match-instance';
+import type { LobbyAPI } from '../types';
+declare enum LobbyPhases {
+    ENTER = "enter",
+    PLAY = "play",
+    LIST = "list"
+}
+declare type RunningMatch = {
+    app: ReturnType<typeof Client>;
+    matchID: string;
+    playerID: string;
+    credentials?: string;
+};
+declare type LobbyProps = {
+    gameComponents: GameComponent[];
+    lobbyServer?: string;
+    gameServer?: string;
+    debug?: DebugOpt | boolean;
+    clientFactory?: typeof Client;
+    refreshInterval?: number;
+    renderer?: (args: {
+        errorMsg: string;
+        gameComponents: GameComponent[];
+        matches: LobbyAPI.MatchList['matches'];
+        phase: LobbyPhases;
+        playerName: string;
+        runningMatch?: RunningMatch;
+        handleEnterLobby: (playerName: string) => void;
+        handleExitLobby: () => Promise<void>;
+        handleCreateMatch: (gameName: string, numPlayers: number) => Promise<void>;
+        handleJoinMatch: (gameName: string, matchID: string, playerID: string) => Promise<void>;
+        handleLeaveMatch: (gameName: string, matchID: string) => Promise<void>;
+        handleExitMatch: () => void;
+        handleRefreshMatches: () => Promise<void>;
+        handleStartMatch: (gameName: string, matchOpts: MatchOpts) => void;
+    }) => JSX.Element;
+};
+declare type LobbyState = {
+    phase: LobbyPhases;
+    playerName: string;
+    runningMatch?: RunningMatch;
+    errorMsg: string;
+    credentialStore?: {
+        [playerName: string]: string;
+    };
+};
+/**
+ * Lobby
+ *
+ * React lobby component.
+ *
+ * @param {Array}  gameComponents - An array of Board and Game objects for the supported games.
+ * @param {string} lobbyServer - Address of the lobby server (for example 'localhost:8000').
+ *                               If not set, defaults to the server that served the page.
+ * @param {string} gameServer - Address of the game server (for example 'localhost:8001').
+ *                              If not set, defaults to the server that served the page.
+ * @param {function} clientFactory - Function that is used to create the game clients.
+ * @param {number} refreshInterval - Interval between server updates (default: 2000ms).
+ * @param {bool}   debug - Enable debug information (default: false).
+ *
+ * Returns:
+ *   A React component that provides a UI to create, list, join, leave, play or
+ *   spectate matches (game instances).
+ */
+declare class Lobby extends React.Component<LobbyProps, LobbyState> {
+    static propTypes: {
+        gameComponents: PropTypes.Validator<any[]>;
+        lobbyServer: PropTypes.Requireable<string>;
+        gameServer: PropTypes.Requireable<string>;
+        debug: PropTypes.Requireable<boolean>;
+        clientFactory: PropTypes.Requireable<(...args: any[]) => any>;
+        refreshInterval: PropTypes.Requireable<number>;
+    };
+    static defaultProps: {
+        debug: boolean;
+        clientFactory: typeof Client;
+        refreshInterval: number;
+    };
+    state: {
+        phase: LobbyPhases;
+        playerName: string;
+        runningMatch: any;
+        errorMsg: string;
+        credentialStore: {};
+    };
+    private connection?;
+    private _currentInterval?;
+    constructor(props: LobbyProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: LobbyProps, prevState: LobbyState): void;
+    componentWillUnmount(): void;
+    _startRefreshInterval(): void;
+    _clearRefreshInterval(): void;
+    _createConnection: (props: LobbyProps) => void;
+    _updateCredentials: (playerName: string, credentials: string) => void;
+    _updateConnection: () => Promise<void>;
+    _enterLobby: (playerName: string) => void;
+    _exitLobby: () => Promise<void>;
+    _createMatch: (gameName: string, numPlayers: number) => Promise<void>;
+    _joinMatch: (gameName: string, matchID: string, playerID: string) => Promise<void>;
+    _leaveMatch: (gameName: string, matchID: string) => Promise<void>;
+    _startMatch: (gameName: string, matchOpts: MatchOpts) => void;
+    _exitMatch: () => void;
+    _getPhaseVisibility: (phase: LobbyPhases) => "hidden" | "phase";
+    renderMatches: (matches: LobbyAPI.MatchList['matches'], playerName: string) => JSX.Element[];
+    render(): JSX.Element;
+}
+export default Lobby;

package/dist/types/src/lobby/react.ssr.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @jest-environment node
+ */
+export {};

package/dist/types/src/lobby/react.test.d.ts

@@ -0,0 +1 @@
+export {};