@mnbroatch/boardgame.io 0.0.1

package/dist/types/src/client/transport/dummy.d.ts

@@ -0,0 +1,18 @@
+import { Transport } from './transport';
+import type { TransportOpts } from './transport';
+/**
+ * This class doesn’t do anything, but simplifies the client class by providing
+ * dummy functions to call, so we don’t need to mock them in the client.
+ */
+declare class DummyImpl extends Transport {
+    connect(): void;
+    disconnect(): void;
+    sendAction(): void;
+    sendChatMessage(): void;
+    requestSync(): void;
+    updateCredentials(): void;
+    updateMatchID(): void;
+    updatePlayerID(): void;
+}
+export declare const DummyTransport: (opts: TransportOpts) => DummyImpl;
+export {};

package/dist/types/src/client/transport/local.d.ts

@@ -0,0 +1,59 @@
+import { Master } from '../../master/master';
+import type { TransportData } from '../../master/master';
+import { Transport } from './transport';
+import type { TransportOpts } from './transport';
+import type { ChatMessage, CredentialedActionShape, Game, PlayerID, State } from '../../types';
+/**
+ * Returns null if it is not a bot's turn.
+ * Otherwise, returns a playerID of a bot that may play now.
+ */
+export declare function GetBotPlayer(state: State, bots: Record<PlayerID, any>): string;
+interface LocalOpts {
+    bots?: Record<PlayerID, any>;
+    persist?: boolean;
+    storageKey?: string;
+}
+declare type LocalMasterOpts = LocalOpts & {
+    game: Game;
+};
+/**
+ * Creates a local version of the master that the client
+ * can interact with.
+ */
+export declare class LocalMaster extends Master {
+    connect: (playerID: PlayerID, callback: (data: TransportData) => void) => void;
+    constructor({ game, bots, storageKey, persist }: LocalMasterOpts);
+}
+declare type LocalTransportOpts = TransportOpts & {
+    master?: LocalMaster;
+};
+/**
+ * Local
+ *
+ * Transport interface that embeds a GameMaster within it
+ * that you can connect multiple clients to.
+ */
+export declare class LocalTransport extends Transport {
+    master: LocalMaster;
+    /**
+     * Creates a new Mutiplayer instance.
+     * @param {string} matchID - The game ID to connect to.
+     * @param {string} playerID - The player ID associated with this client.
+     * @param {string} gameName - The game type (the `name` field in `Game`).
+     * @param {string} numPlayers - The number of players.
+     */
+    constructor({ master, ...opts }: LocalTransportOpts);
+    sendChatMessage(matchID: string, chatMessage: ChatMessage): void;
+    sendAction(state: State, action: CredentialedActionShape.Any): void;
+    requestSync(): void;
+    connect(): void;
+    disconnect(): void;
+    updateMatchID(id: string): void;
+    updatePlayerID(id: PlayerID): void;
+    updateCredentials(credentials?: string): void;
+}
+/**
+ * Create a local transport.
+ */
+export declare function Local({ bots, persist, storageKey }?: LocalOpts): (transportOpts: TransportOpts) => LocalTransport;
+export {};

package/dist/types/src/client/transport/local.test.d.ts

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

package/dist/types/src/client/transport/socketio.d.ts

@@ -0,0 +1,45 @@
+import * as ioNamespace from 'socket.io-client';
+import { Transport } from './transport';
+import type { TransportOpts } from './transport';
+import type { CredentialedActionShape, PlayerID, State, ChatMessage } from '../../types';
+declare type SocketOpts = Partial<ioNamespace.SocketOptions & ioNamespace.ManagerOptions>;
+interface SocketIOOpts {
+    server?: string;
+    socketOpts?: SocketOpts;
+}
+declare type SocketIOTransportOpts = TransportOpts & SocketIOOpts & {
+    socket?: any;
+};
+/**
+ * SocketIO
+ *
+ * Transport interface that interacts with the Master via socket.io.
+ */
+export declare class SocketIOTransport extends Transport {
+    server: string;
+    socket: ioNamespace.Socket;
+    socketOpts: SocketOpts;
+    /**
+     * Creates a new Multiplayer instance.
+     * @param {object} socket - Override for unit tests.
+     * @param {object} socketOpts - Options to pass to socket.io.
+     * @param {object} store - Redux store
+     * @param {string} matchID - The game ID to connect to.
+     * @param {string} playerID - The player ID associated with this client.
+     * @param {string} credentials - Authentication credentials
+     * @param {string} gameName - The game type (the `name` field in `Game`).
+     * @param {string} numPlayers - The number of players.
+     * @param {string} server - The game server in the form of 'hostname:port'. Defaults to the server serving the client if not provided.
+     */
+    constructor({ socket, socketOpts, server, ...opts }: SocketIOTransportOpts);
+    sendAction(state: State, action: CredentialedActionShape.Any): void;
+    sendChatMessage(matchID: string, chatMessage: ChatMessage): void;
+    connect(): void;
+    disconnect(): void;
+    requestSync(): void;
+    updateMatchID(id: string): void;
+    updatePlayerID(id: PlayerID): void;
+    updateCredentials(credentials?: string): void;
+}
+export declare function SocketIO({ server, socketOpts }?: SocketIOOpts): (transportOpts: SocketIOTransportOpts) => SocketIOTransport;
+export {};

package/dist/types/src/client/transport/socketio.test.d.ts

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

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

@@ -0,0 +1,50 @@
+import type { ProcessGameConfig } from '../../core/game';
+import type { TransportData } from '../../master/master';
+import type { Game, PlayerID, CredentialedActionShape, State, SyncInfo, ChatMessage } from '../../types';
+export declare type MetadataCallback = (metadata: SyncInfo['filteredMetadata']) => void;
+export declare type ChatCallback = (message: ChatMessage) => void;
+export interface TransportOpts {
+    transportDataCallback: (data: TransportData) => void;
+    gameName?: string;
+    gameKey: Game;
+    game: ReturnType<typeof ProcessGameConfig>;
+    playerID?: PlayerID;
+    matchID?: string;
+    credentials?: string;
+    numPlayers?: number;
+}
+export declare abstract class Transport {
+    protected gameName: string;
+    protected playerID: PlayerID | null;
+    protected matchID: string;
+    protected credentials?: string;
+    protected numPlayers: number;
+    /** Callback to pass transport data back to the client. */
+    private transportDataCallback;
+    /** Callback to let the client know when the connection status has changed. */
+    private connectionStatusCallback;
+    isConnected: boolean;
+    constructor({ transportDataCallback, gameName, playerID, matchID, credentials, numPlayers, }: TransportOpts);
+    /** Subscribe to connection state changes. */
+    subscribeToConnectionStatus(fn: () => void): void;
+    /** Transport implementations should call this when they connect/disconnect. */
+    protected setConnectionStatus(isConnected: boolean): void;
+    /** Transport implementations should call this when they receive data from a master. */
+    protected notifyClient(data: TransportData): void;
+    /** Called by the client to connect the transport. */
+    abstract connect(): void;
+    /** Called by the client to disconnect the transport. */
+    abstract disconnect(): void;
+    /** Called by the client to dispatch an action via the transport. */
+    abstract sendAction(state: State, action: CredentialedActionShape.Any): void;
+    /** Called by the client to dispatch a chat message via the transport. */
+    abstract sendChatMessage(matchID: string, chatMessage: ChatMessage): void;
+    /** Called by the client to request a sync action from the transport. */
+    abstract requestSync(): void;
+    /** Called by the client to update the matchID it wants to connect to. */
+    abstract updateMatchID(id: string): void;
+    /** Called by the client to update the playerID it is playing as. */
+    abstract updatePlayerID(id: PlayerID): void;
+    /** Called by the client to update the credentials it is using. */
+    abstract updateCredentials(credentials?: string): void;
+}

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

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

package/dist/types/src/core/action-creators.d.ts

@@ -0,0 +1,144 @@
+import type { SyncInfo, State, LogEntry } from '../types';
+import type { Operation } from 'rfc6902';
+/**
+ * Generate a move to be dispatched to the game move reducer.
+ *
+ * @param {string} type - The move type.
+ * @param {Array}  args - Additional arguments.
+ * @param {string}  playerID - The ID of the player making this action.
+ * @param {string}  credentials - (optional) The credentials for the player making this action.
+ */
+export declare const makeMove: (type: string, args?: any, playerID?: string | null, credentials?: string) => {
+    type: "MAKE_MOVE";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+        credentials: string;
+    };
+};
+/**
+ * Generate a game event to be dispatched to the flow reducer.
+ *
+ * @param {string} type - The event type.
+ * @param {Array}  args - Additional arguments.
+ * @param {string}  playerID - The ID of the player making this action.
+ * @param {string}  credentials - (optional) The credentials for the player making this action.
+ */
+export declare const gameEvent: (type: string, args?: any, playerID?: string | null, credentials?: string) => {
+    type: "GAME_EVENT";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+        credentials: string;
+    };
+};
+/**
+ * Generate an automatic game event that is a side-effect of a move.
+ * @param {string} type - The event type.
+ * @param {Array}  args - Additional arguments.
+ * @param {string}  playerID - The ID of the player making this action.
+ * @param {string}  credentials - (optional) The credentials for the player making this action.
+ */
+export declare const automaticGameEvent: (type: string, args: any, playerID?: string | null, credentials?: string) => {
+    type: "GAME_EVENT";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+        credentials: string;
+    };
+    automatic: boolean;
+};
+export declare const sync: (info: SyncInfo) => {
+    type: "SYNC";
+    state: State<any>;
+    log: LogEntry[];
+    initialState: State<any>;
+    clientOnly: true;
+};
+/**
+ * Used to update the Redux store's state with patch in response to
+ * an action coming from another player.
+ * @param prevStateID previous stateID
+ * @param stateID stateID after this patch
+ * @param {Operation[]} patch - The patch to apply.
+ * @param {LogEntry[]} deltalog - A log delta.
+ */
+export declare const patch: (prevStateID: number, stateID: number, patch: Operation[], deltalog: LogEntry[]) => {
+    type: "PATCH";
+    prevStateID: number;
+    stateID: number;
+    patch: Operation[];
+    deltalog: LogEntry[];
+    clientOnly: true;
+};
+/**
+ * Used to update the Redux store's state in response to
+ * an action coming from another player.
+ * @param {object} state - The state to restore.
+ * @param {Array} deltalog - A log delta.
+ */
+export declare const update: (state: State, deltalog: LogEntry[]) => {
+    type: "UPDATE";
+    state: State<any>;
+    deltalog: LogEntry[];
+    clientOnly: true;
+};
+/**
+ * Used to reset the game state.
+ * @param {object} state - The initial state.
+ */
+export declare const reset: (state: State) => {
+    type: "RESET";
+    state: State<any>;
+    clientOnly: true;
+};
+/**
+ * Used to undo the last move.
+ * @param {string}  playerID - The ID of the player making this action.
+ * @param {string}  credentials - (optional) The credentials for the player making this action.
+ */
+export declare const undo: (playerID?: string | null, credentials?: string) => {
+    type: "UNDO";
+    payload: {
+        type: any;
+        args: any;
+        playerID: string;
+        credentials: string;
+    };
+};
+/**
+ * Used to redo the last undone move.
+ * @param {string}  playerID - The ID of the player making this action.
+ * @param {string}  credentials - (optional) The credentials for the player making this action.
+ */
+export declare const redo: (playerID?: string | null, credentials?: string) => {
+    type: "REDO";
+    payload: {
+        type: any;
+        args: any;
+        playerID: string;
+        credentials: string;
+    };
+};
+/**
+ * Allows plugins to define their own actions and intercept them.
+ */
+export declare const plugin: (type: string, args?: any, playerID?: string | null, credentials?: string) => {
+    type: "PLUGIN";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+        credentials: string;
+    };
+};
+/**
+ * Private action used to strip transient metadata (e.g. errors) from the game
+ * state.
+ */
+export declare const stripTransients: () => {
+    type: "STRIP_TRANSIENTS";
+};

package/dist/types/src/core/action-types.d.ts

@@ -0,0 +1,10 @@
+export declare const MAKE_MOVE = "MAKE_MOVE";
+export declare const GAME_EVENT = "GAME_EVENT";
+export declare const REDO = "REDO";
+export declare const RESET = "RESET";
+export declare const SYNC = "SYNC";
+export declare const UNDO = "UNDO";
+export declare const UPDATE = "UPDATE";
+export declare const PATCH = "PATCH";
+export declare const PLUGIN = "PLUGIN";
+export declare const STRIP_TRANSIENTS = "STRIP_TRANSIENTS";

package/dist/types/src/core/backwards-compatibility.d.ts

@@ -0,0 +1,12 @@
+declare type MoveLimitOptions = {
+    minMoves?: number;
+    maxMoves?: number;
+    moveLimit?: number;
+};
+/**
+ * Adjust the given options to use the new minMoves/maxMoves if a legacy moveLimit was given
+ * @param options The options object to apply backwards compatibility to
+ * @param enforceMinMoves Use moveLimit to set both minMoves and maxMoves
+ */
+export declare function supportDeprecatedMoveLimit(options: MoveLimitOptions, enforceMinMoves?: boolean): void;
+export {};

package/dist/types/src/core/constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Moves can return this when they want to indicate
+ * that the combination of arguments is illegal and
+ * the move ought to be discarded.
+ */
+export declare const INVALID_MOVE = "INVALID_MOVE";

package/dist/types/src/core/errors.d.ts

@@ -0,0 +1,15 @@
+export declare enum UpdateErrorType {
+    UnauthorizedAction = "update/unauthorized_action",
+    MatchNotFound = "update/match_not_found",
+    PatchFailed = "update/patch_failed"
+}
+export declare enum ActionErrorType {
+    StaleStateId = "action/stale_state_id",
+    UnavailableMove = "action/unavailable_move",
+    InvalidMove = "action/invalid_move",
+    InactivePlayer = "action/inactive_player",
+    GameOver = "action/gameover",
+    ActionDisabled = "action/action_disabled",
+    ActionInvalid = "action/action_invalid",
+    PluginActionInvalid = "action/plugin_invalid"
+}

package/dist/types/src/core/flow.d.ts

@@ -0,0 +1,28 @@
+import type { ActionPayload, ActionShape, ActivePlayersArg, State, Ctx, Game, PlayerID, Move } from '../types';
+/**
+ * Flow
+ *
+ * Creates a reducer that updates ctx (analogous to how moves update G).
+ */
+export declare function Flow({ moves, phases, endIf, onEnd, turn, events, plugins, }: Game): {
+    ctx: (numPlayers: number) => Ctx;
+    init: (state: State) => State;
+    isPlayerActive: (_G: any, ctx: Ctx, playerID: PlayerID) => boolean;
+    eventHandlers: {
+        endStage: (state: State, playerID: PlayerID) => State;
+        setStage: (state: State, playerID: PlayerID, arg: any) => State;
+        endTurn: (state: State, _playerID: PlayerID, arg: any) => State;
+        pass: (state: State, _playerID: PlayerID, arg: any) => State;
+        endPhase: (state: State) => State;
+        setPhase: (state: State, _playerID: PlayerID, newPhase: string) => State;
+        endGame: (state: State, _playerID: PlayerID, arg: any) => State;
+        setActivePlayers: (state: State, _playerID: PlayerID, arg: ActivePlayersArg) => State;
+    };
+    eventNames: string[];
+    enabledEventNames: any[];
+    moveMap: {};
+    moveNames: unknown[];
+    processMove: (state: State, action: ActionPayload.MakeMove) => State;
+    processEvent: (state: State, action: ActionShape.GameEvent) => State;
+    getMove: (ctx: Ctx, name: string, playerID: PlayerID) => null | Move;
+};

package/dist/types/src/core/flow.test.d.ts

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

package/dist/types/src/core/game-methods.d.ts

@@ -0,0 +1,9 @@
+export declare enum GameMethod {
+    MOVE = "MOVE",
+    GAME_ON_END = "GAME_ON_END",
+    PHASE_ON_BEGIN = "PHASE_ON_BEGIN",
+    PHASE_ON_END = "PHASE_ON_END",
+    TURN_ON_BEGIN = "TURN_ON_BEGIN",
+    TURN_ON_MOVE = "TURN_ON_MOVE",
+    TURN_ON_END = "TURN_ON_END"
+}

package/dist/types/src/core/game.d.ts

@@ -0,0 +1,26 @@
+import { Flow } from './flow';
+import type { INVALID_MOVE } from './constants';
+import type { ActionPayload, Game, Move, LongFormMove, State } from '../types';
+declare type ProcessedGame = Game & {
+    flow: ReturnType<typeof Flow>;
+    moveNames: string[];
+    pluginNames: string[];
+    processMove: (state: State, action: ActionPayload.MakeMove) => State | typeof INVALID_MOVE;
+};
+/**
+ * Helper to generate the game move reducer. The returned
+ * reducer has the following signature:
+ *
+ * (G, action, ctx) => {}
+ *
+ * You can roll your own if you like, or use any Redux
+ * addon to generate such a reducer.
+ *
+ * The convention used in this framework is to
+ * have action.type contain the name of the move, and
+ * action.args contain any additional arguments as an
+ * Array.
+ */
+export declare function ProcessGameConfig(game: Game | ProcessedGame): ProcessedGame;
+export declare function IsLongFormMove(move: Move): move is LongFormMove;
+export {};

package/dist/types/src/core/game.test.d.ts

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

package/dist/types/src/core/initialize.d.ts

@@ -0,0 +1,9 @@
+import type { Game, State } from '../types';
+/**
+ * Creates the initial game state.
+ */
+export declare function InitializeGame({ game, numPlayers, setupData, }: {
+    game: Game;
+    numPlayers?: number;
+    setupData?: any;
+}): State<any>;

package/dist/types/src/core/logger.d.ts

@@ -0,0 +1,2 @@
+export declare function info(msg: string): void;
+export declare function error(error: string): void;

package/dist/types/src/core/player-view.d.ts

@@ -0,0 +1,7 @@
+import type { Game } from '../types';
+/**
+ * PlayerView reducers.
+ */
+export declare const PlayerView: {
+    STRIP_SECRETS: Game['playerView'];
+};

package/dist/types/src/core/player-view.test.d.ts

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

package/dist/types/src/core/reducer.d.ts

@@ -0,0 +1,155 @@
+import type { Dispatch } from 'redux';
+import type { ActionShape, Game, LogEntry, State, Store, TransientMetadata, TransientState } from '../types';
+/**
+ * Middleware for processing TransientState associated with the reducer
+ * returned by CreateGameReducer.
+ * This should pretty much be used everywhere you want realistic state
+ * transitions and error handling.
+ */
+export declare const TransientHandlingMiddleware: (store: Store) => (next: Dispatch<ActionShape.Any>) => (action: ActionShape.Any) => {
+    type: "MAKE_MOVE";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+    };
+} | {
+    type: "GAME_EVENT";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+    };
+} | {
+    type: "UNDO";
+    payload: {
+        type: any;
+        args: any;
+        playerID: string;
+    };
+} | {
+    type: "REDO";
+    payload: {
+        type: any;
+        args: any;
+        playerID: string;
+    };
+} | {
+    type: "SYNC";
+    state: State<any>;
+    log: LogEntry[];
+    initialState: State<any>;
+    clientOnly: true;
+} | {
+    type: "UPDATE";
+    state: State<any>;
+    deltalog: LogEntry[];
+    clientOnly: true;
+} | {
+    type: "PATCH";
+    prevStateID: number;
+    stateID: number;
+    patch: import("rfc6902").Operation[];
+    deltalog: LogEntry[];
+    clientOnly: true;
+} | {
+    type: "RESET";
+    state: State<any>;
+    clientOnly: true;
+} | {
+    type: "PLUGIN";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+    };
+} | {
+    type: "STRIP_TRANSIENTS";
+} | {
+    transients: TransientMetadata;
+    type: "MAKE_MOVE";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+    };
+} | {
+    transients: TransientMetadata;
+    type: "GAME_EVENT";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+    };
+} | {
+    transients: TransientMetadata;
+    type: "UNDO";
+    payload: {
+        type: any;
+        args: any;
+        playerID: string;
+    };
+} | {
+    transients: TransientMetadata;
+    type: "REDO";
+    payload: {
+        type: any;
+        args: any;
+        playerID: string;
+    };
+} | {
+    transients: TransientMetadata;
+    type: "GAME_EVENT";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+    };
+    automatic: boolean;
+} | {
+    transients: TransientMetadata;
+    type: "SYNC";
+    state: State<any>;
+    log: LogEntry[];
+    initialState: State<any>;
+    clientOnly: true;
+} | {
+    transients: TransientMetadata;
+    type: "UPDATE";
+    state: State<any>;
+    deltalog: LogEntry[];
+    clientOnly: true;
+} | {
+    transients: TransientMetadata;
+    type: "PATCH";
+    prevStateID: number;
+    stateID: number;
+    patch: import("rfc6902").Operation[];
+    deltalog: LogEntry[];
+    clientOnly: true;
+} | {
+    transients: TransientMetadata;
+    type: "RESET";
+    state: State<any>;
+    clientOnly: true;
+} | {
+    transients: TransientMetadata;
+    type: "PLUGIN";
+    payload: {
+        type: string;
+        args: any;
+        playerID: string;
+    };
+} | {
+    transients: TransientMetadata;
+    type: "STRIP_TRANSIENTS";
+};
+/**
+ * CreateGameReducer
+ *
+ * Creates the main game state reducer.
+ */
+export declare function CreateGameReducer({ game, isClient, }: {
+    game: Game;
+    isClient?: boolean;
+}): (stateWithTransients: TransientState | null, action: ActionShape.Any) => TransientState;

package/dist/types/src/core/reducer.test.d.ts

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