@mnbroatch/boardgame.io 0.0.1

package/dist/esm/util-b6147cef.js

@@ -0,0 +1,135 @@
+import { I as InitializeGame } from './initialize-11d626ca.js';
+
+var Type;
+(function (Type) {
+    Type[Type["SYNC"] = 0] = "SYNC";
+    Type[Type["ASYNC"] = 1] = "ASYNC";
+})(Type || (Type = {}));
+/**
+ * Type guard that checks if a storage implementation is synchronous.
+ */
+function isSynchronous(storageAPI) {
+    return storageAPI.type() === Type.SYNC;
+}
+class Async {
+    /* istanbul ignore next */
+    type() {
+        /* istanbul ignore next */
+        return Type.ASYNC;
+    }
+    /**
+     * Create a new match.
+     *
+     * This might just need to call setState and setMetadata in
+     * most implementations.
+     *
+     * However, it exists as a separate call so that the
+     * implementation can provision things differently when
+     * a match is created.  For example, it might stow away the
+     * initial match state in a separate field for easier retrieval.
+     */
+    /* istanbul ignore next */
+    async createMatch(matchID, opts) {
+        if (this.createGame) {
+            console.warn('The database connector does not implement a createMatch method.', '\nUsing the deprecated createGame method instead.');
+            return this.createGame(matchID, opts);
+        }
+        else {
+            console.error('The database connector does not implement a createMatch method.');
+        }
+    }
+    /**
+     * Return all matches.
+     */
+    /* istanbul ignore next */
+    async listMatches(opts) {
+        if (this.listGames) {
+            console.warn('The database connector does not implement a listMatches method.', '\nUsing the deprecated listGames method instead.');
+            return this.listGames(opts);
+        }
+        else {
+            console.error('The database connector does not implement a listMatches method.');
+        }
+    }
+}
+class Sync {
+    type() {
+        return Type.SYNC;
+    }
+    /**
+     * Connect.
+     */
+    connect() {
+        return;
+    }
+    /**
+     * Create a new match.
+     *
+     * This might just need to call setState and setMetadata in
+     * most implementations.
+     *
+     * However, it exists as a separate call so that the
+     * implementation can provision things differently when
+     * a match is created.  For example, it might stow away the
+     * initial match state in a separate field for easier retrieval.
+     */
+    /* istanbul ignore next */
+    createMatch(matchID, opts) {
+        if (this.createGame) {
+            console.warn('The database connector does not implement a createMatch method.', '\nUsing the deprecated createGame method instead.');
+            return this.createGame(matchID, opts);
+        }
+        else {
+            console.error('The database connector does not implement a createMatch method.');
+        }
+    }
+    /**
+     * Return all matches.
+     */
+    /* istanbul ignore next */
+    listMatches(opts) {
+        if (this.listGames) {
+            console.warn('The database connector does not implement a listMatches method.', '\nUsing the deprecated listGames method instead.');
+            return this.listGames(opts);
+        }
+        else {
+            console.error('The database connector does not implement a listMatches method.');
+        }
+    }
+}
+
+/**
+ * Creates a new match metadata object.
+ */
+const createMetadata = ({ game, unlisted, setupData, numPlayers, }) => {
+    const metadata = {
+        gameName: game.name,
+        unlisted: !!unlisted,
+        players: {},
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    };
+    if (setupData !== undefined)
+        metadata.setupData = setupData;
+    for (let playerIndex = 0; playerIndex < numPlayers; playerIndex++) {
+        metadata.players[playerIndex] = { id: playerIndex };
+    }
+    return metadata;
+};
+/**
+ * Creates initial state and metadata for a new match.
+ * If the provided `setupData` doesn’t pass the game’s validation,
+ * an error object is returned instead.
+ */
+const createMatch = ({ game, numPlayers, setupData, unlisted, }) => {
+    if (!numPlayers || typeof numPlayers !== 'number')
+        numPlayers = 2;
+    const setupDataError = game.validateSetupData && game.validateSetupData(setupData, numPlayers);
+    if (setupDataError !== undefined)
+        return { setupDataError };
+    const metadata = createMetadata({ game, numPlayers, setupData, unlisted });
+    const initialState = InitializeGame({ game, numPlayers, setupData });
+    return { metadata, initialState };
+};
+
+export { Async as A, Sync as S, createMatch as c, isSynchronous as i };

package/dist/types/packages/ai.d.ts

@@ -0,0 +1,5 @@
+import { Step, Simulate } from '../src/ai/ai';
+import { Bot } from '../src/ai/bot';
+import { RandomBot } from '../src/ai/random-bot';
+import { MCTSBot } from '../src/ai/mcts-bot';
+export { Bot, RandomBot, MCTSBot, Step, Simulate };

package/dist/types/packages/client.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '../src/client/client';
+import { LobbyClient, LobbyClientError } from '../src/lobby/client';
+export { Client, LobbyClient, LobbyClientError };

package/dist/types/packages/core.d.ts

@@ -0,0 +1,5 @@
+import { INVALID_MOVE } from '../src/core/constants';
+import { GameMethod } from '../src/core/game-methods';
+import { ActivePlayers, TurnOrder, Stage } from '../src/core/turn-order';
+import { PlayerView } from '../src/core/player-view';
+export { ActivePlayers, GameMethod, Stage, TurnOrder, PlayerView, INVALID_MOVE, };

package/dist/types/packages/debug.d.ts

@@ -0,0 +1,2 @@
+import Debug from '../src/client/debug/Debug.svelte';
+export { Debug };

package/dist/types/packages/internal.d.ts

@@ -0,0 +1,8 @@
+import { InitializeGame } from '../src/core/initialize';
+import { ProcessGameConfig } from '../src/core/game';
+import { CreateGameReducer } from '../src/core/reducer';
+import { getFilterPlayerView } from '../src/master/filter-player-view';
+import { Async, Sync } from '../src/server/db/base';
+import { Transport } from '../src/client/transport/transport';
+import { createMatch } from '../src/server/util';
+export { Async, Sync, Transport, ProcessGameConfig, InitializeGame, CreateGameReducer, createMatch, getFilterPlayerView, };

package/dist/types/packages/master.d.ts

@@ -0,0 +1,2 @@
+import { Master } from '../src/master/master';
+export { Master };

package/dist/types/packages/multiplayer.d.ts

@@ -0,0 +1,3 @@
+import { Local } from '../src/client/transport/local';
+import { SocketIO } from '../src/client/transport/socketio';
+export { Local, SocketIO };

package/dist/types/packages/plugins.d.ts

@@ -0,0 +1,3 @@
+import PluginPlayer from '../src/plugins/plugin-player';
+import { PlayerPlugin } from '../src/plugins/plugin-player';
+export { PluginPlayer, PlayerPlugin };

package/dist/types/packages/react-native.d.ts

@@ -0,0 +1,2 @@
+import { Client } from '../src/client/react-native';
+export { Client };

package/dist/types/packages/react.d.ts

@@ -0,0 +1,3 @@
+import { Client, BoardProps } from '../src/client/react';
+import Lobby from '../src/lobby/react';
+export { Client, BoardProps, Lobby };

package/dist/types/packages/server.d.ts

@@ -0,0 +1,6 @@
+import { Server, configureRouter, configureApp, createServerRunConfig, getPortFromServer } from '../src/server';
+import { Origins } from '../src/server/cors';
+import { FlatFile } from '../src/server/db';
+import { SocketIO, Master, TransportAPI } from '../src/server/transport/socketio';
+import { GenericPubSub } from '../src/server/transport/pubsub/generic-pub-sub';
+export { Server, Origins, FlatFile, SocketIO, GenericPubSub, configureRouter, configureApp, createServerRunConfig, getPortFromServer, Master, TransportAPI, };

package/dist/types/packages/testing.d.ts

@@ -0,0 +1 @@
+export { MockRandom } from '../src/testing/mock-random';

package/dist/types/src/ai/ai.d.ts

@@ -0,0 +1,53 @@
+import { Bot } from './bot';
+import type { Game, PlayerID, State, Store } from '../types';
+/**
+ * Make a single move on the client with a bot.
+ *
+ * @param {...object} client - The game client.
+ * @param {...object} bot - The bot.
+ */
+export declare function Step(client: {
+    store: Store;
+}, bot: Bot): Promise<{
+    payload: {
+        metadata: any;
+        type: string;
+        args: any;
+        playerID: string;
+    } | {
+        metadata: any;
+        type: string;
+        args: any;
+        playerID: string;
+    };
+    type: "MAKE_MOVE";
+} | {
+    payload: {
+        metadata: any;
+        type: string;
+        args: any;
+        playerID: string;
+    } | {
+        metadata: any;
+        type: string;
+        args: any;
+        playerID: string;
+    };
+    type: "GAME_EVENT";
+}>;
+/**
+ * Simulates the game till the end or a max depth.
+ *
+ * @param {...object} game - The game object.
+ * @param {...object} bots - An array of bots.
+ * @param {...object} state - The game state to start from.
+ */
+export declare function Simulate({ game, bots, state, depth, }: {
+    game: Game;
+    bots: Bot | Record<PlayerID, Bot>;
+    state: State;
+    depth?: number;
+}): Promise<{
+    state: State<any>;
+    metadata: any;
+}>;

package/dist/types/src/ai/ai.test.d.ts

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

package/dist/types/src/ai/bot.d.ts

@@ -0,0 +1,40 @@
+import type { ActionShape, Game, Ctx, PlayerID, State } from '../types';
+export declare type BotAction = ActionShape.GameEvent | ActionShape.MakeMove;
+/**
+ * Base class that bots can extend.
+ */
+export declare abstract class Bot {
+    private enumerateFn;
+    private seed?;
+    protected iterationCounter: number;
+    private _opts;
+    private prngstate?;
+    constructor({ enumerate, seed, }: {
+        enumerate: Game['ai']['enumerate'];
+        seed?: string | number;
+    });
+    abstract play(state: State, playerID: PlayerID): Promise<{
+        action: BotAction;
+        metadata?: any;
+    }>;
+    addOpt({ key, range, initial, }: {
+        key: string;
+        range?: {
+            min: number;
+            max: number;
+        };
+        initial: any;
+    }): void;
+    getOpt(key: string): any;
+    setOpt(key: string, value: any): void;
+    opts(): Record<string, {
+        range?: {
+            min: number;
+            max: number;
+        };
+        value: any;
+    }>;
+    enumerate(G: any, ctx: Ctx, playerID: PlayerID): BotAction[];
+    random<T extends any = any>(arg: T[]): T;
+    random(arg?: number): number;
+}

package/dist/types/src/ai/mcts-bot.d.ts

@@ -0,0 +1,60 @@
+import 'setimmediate';
+import { Bot } from './bot';
+import type { BotAction } from './bot';
+import type { Game, PlayerID, Ctx, State } from '../types';
+export interface Node {
+    /** Game state at this node. */
+    state: State;
+    /** Parent of the node. */
+    parent?: Node;
+    /** Move used to get to this node. */
+    parentAction?: BotAction;
+    /** Unexplored actions. */
+    actions: BotAction[];
+    /** Current objectives. */
+    objectives: Objectives | Objectives[];
+    /** Children of the node. */
+    children: Node[];
+    /** Number of simulations that pass through this node. */
+    visits: number;
+    /** Number of wins for this node. */
+    value: number;
+}
+interface Objective {
+    checker: (G: any, ctx: Ctx) => boolean;
+    weight: number;
+}
+declare type Objectives = Record<string, Objective>;
+/**
+ * Bot that uses Monte-Carlo Tree Search to find promising moves.
+ */
+export declare class MCTSBot extends Bot {
+    private objectives;
+    private iterationCallback;
+    private reducer;
+    iterations: number | ((G: any, ctx: Ctx, playerID?: PlayerID) => number);
+    playoutDepth?: number | ((G: any, ctx: Ctx, playerID?: PlayerID) => number);
+    constructor({ enumerate, seed, objectives, game, iterations, playoutDepth, iterationCallback, }: {
+        enumerate: Game['ai']['enumerate'];
+        seed?: string | number;
+        game: Game;
+        objectives?: (G: any, ctx: Ctx, playerID?: PlayerID) => Objectives;
+        iterations?: number | ((G: any, ctx: Ctx, playerID?: PlayerID) => number);
+        playoutDepth?: number | ((G: any, ctx: Ctx, playerID?: PlayerID) => number);
+        iterationCallback?: (data: {
+            iterationCounter: number;
+            numIterations: number;
+            metadata: Node;
+        }) => void;
+    });
+    private createNode;
+    private select;
+    private expand;
+    playout({ state }: Node): any;
+    private backpropagate;
+    play(state: State, playerID: PlayerID): Promise<{
+        action: BotAction;
+        metadata: Node;
+    }>;
+}
+export {};

package/dist/types/src/ai/random-bot.d.ts

@@ -0,0 +1,27 @@
+import { Bot } from './bot';
+import type { Ctx, PlayerID } from '../types';
+/**
+ * Bot that picks a move at random.
+ */
+export declare class RandomBot extends Bot {
+    play({ G, ctx }: {
+        G: any;
+        ctx: Ctx;
+    }, playerID: PlayerID): Promise<{
+        action: {
+            type: "MAKE_MOVE";
+            payload: {
+                type: string;
+                args: any;
+                playerID: string;
+            };
+        } | {
+            type: "GAME_EVENT";
+            payload: {
+                type: string;
+                args: any;
+                playerID: string;
+            };
+        };
+    }>;
+}

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

@@ -0,0 +1,104 @@
+import 'svelte';
+import type { StoreEnhancer } from 'redux';
+import { ProcessGameConfig } from '../core/game';
+import type Debug from './debug/Debug.svelte';
+import type { Transport, TransportOpts } from './transport/transport';
+import type { ActivePlayersArg, FilteredMetadata, Game, LogEntry, PlayerID, State, Store, ChatMessage } from '../types';
+export interface DebugOpt {
+    target?: HTMLElement;
+    impl?: typeof Debug;
+    collapseOnLoad?: boolean;
+    hideToggleButton?: boolean;
+}
+export declare const createMoveDispatchers: any;
+export declare const createEventDispatchers: any;
+export declare const createPluginDispatchers: any;
+export interface ClientOpts<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    game: Game<G, PluginAPIs>;
+    debug?: DebugOpt | boolean;
+    numPlayers?: number;
+    multiplayer?: (opts: TransportOpts) => Transport;
+    matchID?: string;
+    playerID?: PlayerID;
+    credentials?: string;
+    enhancer?: StoreEnhancer;
+}
+export declare type ClientState<G extends any = any> = null | (State<G> & {
+    isActive: boolean;
+    isConnected: boolean;
+    log: LogEntry[];
+});
+/**
+ * Implementation of Client (see below).
+ */
+export declare class _ClientImpl<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    private gameStateOverride?;
+    private initialState;
+    readonly multiplayer: (opts: TransportOpts) => Transport;
+    private reducer;
+    private _running;
+    private subscribers;
+    private transport;
+    private manager;
+    readonly debugOpt?: DebugOpt | boolean;
+    readonly game: ReturnType<typeof ProcessGameConfig>;
+    readonly store: Store;
+    log: State['deltalog'];
+    matchID: string;
+    playerID: PlayerID | null;
+    credentials: string;
+    matchData?: FilteredMetadata;
+    moves: Record<string, (...args: any[]) => void>;
+    events: {
+        endGame?: (gameover?: any) => void;
+        endPhase?: () => void;
+        endTurn?: (arg?: {
+            next: PlayerID;
+        }) => void;
+        setPhase?: (newPhase: string) => void;
+        endStage?: () => void;
+        setStage?: (newStage: string) => void;
+        setActivePlayers?: (arg: ActivePlayersArg) => void;
+    };
+    plugins: Record<string, (...args: any[]) => void>;
+    reset: () => void;
+    undo: () => void;
+    redo: () => void;
+    sendChatMessage: (message: any) => void;
+    chatMessages: ChatMessage[];
+    constructor({ game, debug, numPlayers, multiplayer, matchID: matchID, playerID, credentials, enhancer, }: ClientOpts<G, PluginAPIs>);
+    /** Handle incoming match data from a multiplayer transport. */
+    private receiveMatchData;
+    /** Handle an incoming chat message from a multiplayer transport. */
+    private receiveChatMessage;
+    /** Handle all incoming updates from a multiplayer transport. */
+    private receiveTransportData;
+    private notifySubscribers;
+    overrideGameState(state: any): void;
+    start(): void;
+    stop(): void;
+    subscribe(fn: (state: ClientState<G>) => void): () => void;
+    getInitialState(): State<G>;
+    getState(): ClientState<G>;
+    private createDispatchers;
+    updatePlayerID(playerID: PlayerID | null): void;
+    updateMatchID(matchID: string): void;
+    updateCredentials(credentials: string): void;
+}
+/**
+ * Client
+ *
+ * boardgame.io JS client.
+ *
+ * @param {...object} game - The return value of `Game`.
+ * @param {...object} numPlayers - The number of players.
+ * @param {...object} multiplayer - Set to a falsy value or a transportFactory, e.g., SocketIO()
+ * @param {...object} matchID - The matchID that you want to connect to.
+ * @param {...object} playerID - The playerID associated with this client.
+ * @param {...string} credentials - The authentication credentials associated with this client.
+ *
+ * Returns:
+ *   A JS object that provides an API to interact with the
+ *   game by dispatching moves and events.
+ */
+export declare function Client<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>>(opts: ClientOpts<G, PluginAPIs>): _ClientImpl<G, PluginAPIs>;

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

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

package/dist/types/src/client/debug/tests/debug.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

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

@@ -0,0 +1,61 @@
+import type { _ClientImpl } from './client';
+declare type SubscriptionState = {
+    client: _ClientImpl;
+    debuggableClients: _ClientImpl[];
+};
+declare type SubscribeCallback = (arg: SubscriptionState) => void;
+declare type UnsubscribeCallback = () => void;
+/**
+ * Class to manage boardgame.io clients and limit debug panel rendering.
+ */
+export declare class ClientManager {
+    private debugPanel;
+    private currentClient;
+    private clients;
+    private subscribers;
+    constructor();
+    /**
+     * Register a client with the client manager.
+     */
+    register(client: _ClientImpl): void;
+    /**
+     * Unregister a client from the client manager.
+     */
+    unregister(client: _ClientImpl): void;
+    /**
+     * Subscribe to the client manager state.
+     * Calls the passed callback each time the current client changes or a client
+     * registers/unregisters.
+     * Returns a function to unsubscribe from the state updates.
+     */
+    subscribe(callback: SubscribeCallback): UnsubscribeCallback;
+    /**
+     * Switch to a client with a matching playerID.
+     */
+    switchPlayerID(playerID: string): void;
+    /**
+     * Set the passed client as the active client for debugging.
+     */
+    switchToClient(client: _ClientImpl): void;
+    /**
+     * Notify all subscribers of changes to the client manager state.
+     */
+    private notifySubscribers;
+    /**
+     * Get the client manager state.
+     */
+    private getState;
+    /**
+     * Get an array of the registered clients that haven’t disabled the debug panel.
+     */
+    private getDebuggableClients;
+    /**
+     * Mount the debug panel using the passed client.
+     */
+    private mountDebug;
+    /**
+     * Unmount the debug panel.
+     */
+    private unmountDebug;
+}
+export {};

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

@@ -0,0 +1,75 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import type { ClientOpts, ClientState, _ClientImpl } from './client';
+declare type WrappedBoardDelegates = 'matchID' | 'playerID' | 'credentials';
+export declare type WrappedBoardProps = Pick<ClientOpts, WrappedBoardDelegates | 'debug'>;
+declare type ExposedClientProps<G extends any = any> = Pick<_ClientImpl<G>, 'log' | 'moves' | 'events' | 'reset' | 'undo' | 'redo' | 'playerID' | 'matchID' | 'matchData' | 'sendChatMessage' | 'chatMessages'>;
+export declare type BoardProps<G extends any = any> = ClientState<G> & Omit<WrappedBoardProps, keyof ExposedClientProps<G>> & ExposedClientProps<G> & {
+    isMultiplayer: boolean;
+};
+declare type ReactClientOpts<G extends any = any, P extends BoardProps<G> = BoardProps<G>, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> = Omit<ClientOpts<G, PluginAPIs>, WrappedBoardDelegates> & {
+    board?: React.ComponentType<P>;
+    loading?: React.ComponentType;
+};
+/**
+ * Client
+ *
+ * boardgame.io React client.
+ *
+ * @param {...object} game - The return value of `Game`.
+ * @param {...object} numPlayers - The number of players.
+ * @param {...object} board - The React component for the game.
+ * @param {...object} loading - (optional) The React component for the loading state.
+ * @param {...object} multiplayer - Set to a falsy value or a transportFactory, e.g., SocketIO()
+ * @param {...object} debug - Enables the Debug UI.
+ * @param {...object} enhancer - Optional enhancer to send to the Redux store
+ *
+ * Returns:
+ *   A React component that wraps board and provides an
+ *   API through props for it to interact with the framework
+ *   and dispatch actions such as MAKE_MOVE, GAME_EVENT, RESET,
+ *   UNDO and REDO.
+ */
+export declare function Client<G extends any = any, P extends BoardProps<G> = BoardProps<G>, PluginAPIs extends Record<string, unknown> = Record<string, unknown>>(opts: ReactClientOpts<G, P, PluginAPIs>): {
+    new (props: Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>): {
+        client: _ClientImpl<G>;
+        unsubscribe?: () => void;
+        componentDidMount(): void;
+        componentWillUnmount(): void;
+        componentDidUpdate(prevProps: Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Pick<ClientOpts<any, Record<string, unknown>>, "matchID" | "playerID" | "credentials" | "debug"> & Pick<P, Exclude<keyof P, "matchID" | "playerID" | "credentials" | "debug" | "log" | "moves" | "events" | "reset" | "undo" | "redo" | "matchData" | "sendChatMessage" | "chatMessages" | "plugins" | "deltalog" | "G" | "ctx" | "_undo" | "_redo" | "_stateID" | "isActive" | "isConnected" | "isMultiplayer">>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        matchID: PropTypes.Requireable<string>;
+        playerID: PropTypes.Requireable<string>;
+        credentials: PropTypes.Requireable<string>;
+        debug: PropTypes.Requireable<any>;
+    };
+    defaultProps: {
+        matchID: string;
+        playerID: any;
+        credentials: any;
+        debug: boolean;
+    };
+    contextType?: React.Context<any>;
+};
+export {};

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

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

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

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