@mnbroatch/boardgame.io 0.0.1

package/dist/types/src/master/filter-player-view.d.ts

@@ -0,0 +1,96 @@
+import type { Game, LogEntry, PlayerID } from '../types';
+import type { TransportData, IntermediateTransportData } from './master';
+/** Gets a function that filters the TransportData for a given player and game. */
+export declare const getFilterPlayerView: (game: Game) => (playerID: string | null, payload: IntermediateTransportData) => TransportData;
+/**
+ * Redact the log.
+ *
+ * @param {Array} log - The game log (or deltalog).
+ * @param {String} playerID - The playerID that this log is
+ *                            to be sent to.
+ */
+export declare function redactLog(log: LogEntry[], playerID: PlayerID | null): {
+    action: {
+        payload: {
+            args: any;
+            type: string;
+            playerID: string;
+        } | {
+            args: any;
+            type: string;
+            playerID: string;
+        } | {
+            args: any;
+            type: any;
+            playerID: string;
+        } | {
+            args: any;
+            type: any;
+            playerID: string;
+        };
+        type: "MAKE_MOVE";
+    } | {
+        payload: {
+            args: any;
+            type: string;
+            playerID: string;
+        } | {
+            args: any;
+            type: string;
+            playerID: string;
+        } | {
+            args: any;
+            type: any;
+            playerID: string;
+        } | {
+            args: any;
+            type: any;
+            playerID: string;
+        };
+        type: "GAME_EVENT";
+    } | {
+        payload: {
+            args: any;
+            type: string;
+            playerID: string;
+        } | {
+            args: any;
+            type: string;
+            playerID: string;
+        } | {
+            args: any;
+            type: any;
+            playerID: string;
+        } | {
+            args: any;
+            type: any;
+            playerID: string;
+        };
+        type: "UNDO";
+    } | {
+        payload: {
+            args: any;
+            type: string;
+            playerID: string;
+        } | {
+            args: any;
+            type: string;
+            playerID: string;
+        } | {
+            args: any;
+            type: any;
+            playerID: string;
+        } | {
+            args: any;
+            type: any;
+            playerID: string;
+        };
+        type: "REDO";
+    };
+    _stateID: number;
+    turn: number;
+    phase: string;
+    automatic?: boolean;
+    metadata?: any;
+    patch?: import("rfc6902").Operation[];
+}[];

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

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

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

@@ -0,0 +1,94 @@
+import { ProcessGameConfig } from '../core/game';
+import type { SyncInfo, FilteredMetadata, Game, State, ActionShape, CredentialedActionShape, LogEntry, PlayerID, ChatMessage } from '../types';
+import type { Auth } from '../server/auth';
+import * as StorageAPI from '../server/db/base';
+import type { Operation } from 'rfc6902';
+declare type CallbackFn = (arg: {
+    state: State;
+    matchID: string;
+    action?: ActionShape.Any | CredentialedActionShape.Any;
+}) => void;
+/**
+ * Data types that are shared across `TransportData` and `IntermediateTransportData`.
+ */
+declare type CommonTransportData = {
+    type: 'sync';
+    args: [string, SyncInfo];
+} | {
+    type: 'matchData';
+    args: [string, FilteredMetadata];
+} | {
+    type: 'chat';
+    args: [string, ChatMessage];
+};
+/**
+ * Final shape of data sent by the transport API
+ * to be received by clients/client transports.
+ */
+export declare type TransportData = {
+    type: 'update';
+    args: [string, State, LogEntry[]];
+} | {
+    type: 'patch';
+    args: [string, number, number, Operation[], LogEntry[]];
+} | CommonTransportData;
+/**
+ * Data type sent by a master to its transport API. The transport then transforms
+ * this into `TransportData` for each individual player it forwards it to.
+ */
+export declare type IntermediateTransportData = {
+    type: 'update';
+    args: [string, State];
+} | {
+    type: 'patch';
+    args: [string, number, State, State];
+} | CommonTransportData;
+/** API used by a master to emit data to any connected clients/client transports. */
+export interface TransportAPI {
+    send: (playerData: {
+        playerID: PlayerID;
+    } & IntermediateTransportData) => void;
+    sendAll: (payload: IntermediateTransportData) => void;
+}
+/**
+ * Master
+ *
+ * Class that runs the game and maintains the authoritative state.
+ * It uses the transportAPI to communicate with clients and the
+ * storageAPI to communicate with the database.
+ */
+export declare class Master {
+    game: ReturnType<typeof ProcessGameConfig>;
+    storageAPI: StorageAPI.Sync | StorageAPI.Async;
+    transportAPI: TransportAPI;
+    subscribeCallback: CallbackFn;
+    auth?: Auth;
+    constructor(game: Game, storageAPI: StorageAPI.Sync | StorageAPI.Async, transportAPI: TransportAPI, auth?: Auth);
+    subscribe(fn: CallbackFn): void;
+    /**
+     * Called on each move / event made by the client.
+     * Computes the new value of the game state and returns it
+     * along with a deltalog.
+     */
+    onUpdate(credAction: CredentialedActionShape.Any, stateID: number, matchID: string, playerID: string): Promise<void | {
+        error: string;
+    }>;
+    /**
+     * Called when the client connects / reconnects.
+     * Returns the latest game state and the entire log.
+     */
+    onSync(matchID: string, playerID: string | null | undefined, credentials?: string, numPlayers?: number): Promise<void | {
+        error: string;
+    }>;
+    /**
+     * Called when a client connects or disconnects.
+     * Updates and sends out metadata to reflect the player’s connection status.
+     */
+    onConnectionChange(matchID: string, playerID: string | null | undefined, credentials: string | undefined, connected: boolean): Promise<void | {
+        error: string;
+    }>;
+    onChatMessage(matchID: string, chatMessage: ChatMessage, credentials: string | undefined): Promise<void | {
+        error: string;
+    }>;
+}
+export {};

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

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

package/dist/types/src/plugins/events/events.d.ts

@@ -0,0 +1,54 @@
+import type { State, Ctx, PlayerID, Game, ActivePlayersArg } from '../../types';
+import { GameMethod } from '../../core/game-methods';
+export interface EventsAPI {
+    endGame(gameover?: any): void;
+    endPhase(): void;
+    endStage(): void;
+    endTurn(arg?: {
+        next: PlayerID;
+    }): void;
+    pass(arg?: {
+        remove: true;
+    }): void;
+    setActivePlayers(arg: ActivePlayersArg): void;
+    setPhase(newPhase: string): void;
+    setStage(newStage: string): void;
+}
+export interface PrivateEventsAPI {
+    _private: {
+        isUsed(): boolean;
+        updateTurnContext(ctx: Ctx, methodType: GameMethod | undefined): void;
+        unsetCurrentMethod(): void;
+        update(state: State): State;
+    };
+}
+/**
+ * Events
+ */
+export declare class Events {
+    flow: Game['flow'];
+    playerID: PlayerID | undefined;
+    dispatch: Array<{
+        type: string;
+        args: any[];
+        phase: string;
+        turn: number;
+        calledFrom: GameMethod | undefined;
+        error: Error;
+    }>;
+    maxEndedTurnsPerAction: number;
+    initialTurn: number;
+    currentPhase: string;
+    currentTurn: number;
+    currentMethod?: GameMethod;
+    constructor(flow: Game['flow'], ctx: Ctx, playerID?: PlayerID);
+    api(): EventsAPI & PrivateEventsAPI;
+    isUsed(): boolean;
+    updateTurnContext(ctx: Ctx, methodType: GameMethod | undefined): void;
+    unsetCurrentMethod(): void;
+    /**
+     * Updates ctx with the triggered events.
+     * @param {object} state - The state object { G, ctx }.
+     */
+    update(state: State): State;
+}

package/dist/types/src/plugins/events/events.test.d.ts

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

package/dist/types/src/plugins/main.d.ts

@@ -0,0 +1,75 @@
+import type { AnyFn, DefaultPluginAPIs, PartialGameState, State, Game, Plugin, ActionShape, PlayerID } from '../types';
+import type { GameMethod } from '../core/game-methods';
+interface PluginOpts {
+    game: Game;
+    isClient?: boolean;
+}
+/**
+ * Allow plugins to intercept actions and process them.
+ */
+export declare const ProcessAction: (state: State, action: ActionShape.Plugin, opts: PluginOpts) => State;
+/**
+ * The APIs created by various plugins are stored in the plugins
+ * section of the state object:
+ *
+ * {
+ *   G: {},
+ *   ctx: {},
+ *   plugins: {
+ *     plugin-a: {
+ *       data: {},  // this is generated by the plugin at Setup / Flush.
+ *       api: {},   // this is ephemeral and generated by Enhance.
+ *     }
+ *   }
+ * }
+ *
+ * This function retrieves plugin APIs and returns them as an object
+ * for consumption as used by move contexts.
+ */
+export declare const GetAPIs: ({ plugins }: PartialGameState) => DefaultPluginAPIs;
+/**
+ * Applies the provided plugins to the given move / flow function.
+ *
+ * @param methodToWrap - The move function or hook to apply the plugins to.
+ * @param methodType - The type of the move or hook being wrapped.
+ * @param plugins - The list of plugins.
+ */
+export declare const FnWrap: (methodToWrap: AnyFn, methodType: GameMethod, plugins: Plugin[]) => (context: import("../types").FnContext<any, Record<string, unknown>>, ...args: any[]) => any;
+/**
+ * Allows the plugin to generate its initial state.
+ */
+export declare const Setup: (state: PartialGameState, opts: PluginOpts) => PartialGameState;
+/**
+ * Invokes the plugin before a move or event.
+ * The API that the plugin generates is stored inside
+ * the `plugins` section of the state (which is subsequently
+ * merged into ctx).
+ */
+export declare const Enhance: <S extends State<any> | Pick<State<any>, "G" | "ctx" | "plugins">>(state: S, opts: PluginOpts & {
+    playerID: PlayerID;
+}) => S;
+/**
+ * Allows plugins to indicate if they should not be materialized on the client.
+ * This will cause the client to discard the state update and wait for the
+ * master instead.
+ */
+export declare const NoClient: (state: State, opts: PluginOpts) => boolean;
+/**
+ * Update plugin state after move/event & check if plugins consider the update to be valid.
+ * @returns Tuple of `[updatedState]` or `[originalState, invalidError]`.
+ */
+export declare const FlushAndValidate: (state: State, opts: PluginOpts) => readonly [State<any>] | readonly [State<any>, {
+    plugin: string;
+    message: string;
+}];
+/**
+ * Allows plugins to customize their data for specific players.
+ * For example, a plugin may want to share no data with the client, or
+ * want to keep some player data secret from opponents.
+ */
+export declare const PlayerView: ({ G, ctx, plugins }: State, { game, playerID }: PluginOpts & {
+    playerID: PlayerID;
+}) => {
+    [pluginName: string]: import("../types").PluginState;
+};
+export {};

package/dist/types/src/plugins/main.test.d.ts

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

package/dist/types/src/plugins/plugin-events.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from '../types';
+import type { PrivateEventsAPI, EventsAPI } from './events/events';
+export type { EventsAPI };
+declare const EventsPlugin: Plugin<EventsAPI & PrivateEventsAPI>;
+export default EventsPlugin;

package/dist/types/src/plugins/plugin-immer.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from '../types';
+/**
+ * Plugin that allows using Immer to make immutable changes
+ * to G by just mutating it.
+ */
+declare const ImmerPlugin: Plugin;
+export default ImmerPlugin;

package/dist/types/src/plugins/plugin-immer.test.d.ts

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

package/dist/types/src/plugins/plugin-log.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from '../types';
+interface LogData {
+    metadata?: any;
+}
+export interface LogAPI {
+    setMetadata(metadata: any): void;
+}
+/**
+ * Plugin that makes it possible to add metadata to log entries.
+ * During a move, you can set metadata using ctx.log.setMetadata and it will be
+ * available on the log entry for that move.
+ */
+declare const LogPlugin: Plugin<LogAPI, LogData>;
+export default LogPlugin;

package/dist/types/src/plugins/plugin-log.test.d.ts

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

package/dist/types/src/plugins/plugin-player.d.ts

@@ -0,0 +1,29 @@
+import type { Plugin, PlayerID } from '../types';
+interface PlayerData<PlayerState extends any = any> {
+    players: Record<PlayerID, PlayerState>;
+}
+export interface PlayerAPI<PlayerState extends any = any> {
+    state: Record<PlayerID, PlayerState>;
+    get(): PlayerState;
+    set(value: PlayerState): PlayerState;
+    opponent?: {
+        get(): PlayerState;
+        set(value: PlayerState): PlayerState;
+    };
+}
+interface PluginPlayerOpts<PlayerState extends any = any> {
+    setup?: (playerID: string) => PlayerState;
+    playerView?: (players: Record<PlayerID, PlayerState>, playerID?: string | null) => any;
+}
+export interface PlayerPlugin<PlayerState extends any = any> {
+    player: PlayerAPI<PlayerState>;
+}
+/**
+ * Plugin that maintains state for each player in G.players.
+ * During a turn, G.player will contain the object for the current player.
+ * In two player games, G.opponent will contain the object for the other player.
+ *
+ * @param {function} initPlayerState - Function of type (playerID) => playerState.
+ */
+declare const PlayerPlugin: <PlayerState extends unknown = any>({ setup, playerView, }?: PluginPlayerOpts<PlayerState>) => Plugin<PlayerAPI<PlayerState>, PlayerData<PlayerState>, any>;
+export default PlayerPlugin;

package/dist/types/src/plugins/plugin-player.test.d.ts

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

package/dist/types/src/plugins/plugin-random.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '../types';
+import type { RandomAPI, PrivateRandomAPI, RandomState } from './random/random';
+declare const RandomPlugin: Plugin<RandomAPI & PrivateRandomAPI, RandomState>;
+export default RandomPlugin;

package/dist/types/src/plugins/plugin-serializable.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from '../types';
+/**
+ * Plugin that checks whether state is serializable, in order to avoid
+ * network serialization bugs.
+ */
+declare const SerializablePlugin: Plugin;
+export default SerializablePlugin;

package/dist/types/src/plugins/plugin-serializable.test.d.ts

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

package/dist/types/src/plugins/random/random.alea.d.ts

@@ -0,0 +1,19 @@
+export interface AleaState {
+    c: number;
+    s0: number;
+    s1: number;
+    s2: number;
+}
+declare class Alea {
+    c: number;
+    s0: number;
+    s1: number;
+    s2: number;
+    constructor(seed: string | number);
+    next(): number;
+}
+declare type PRNG = Alea['next'] & {
+    state?: () => AleaState;
+};
+export declare function alea(seed: string | number, state?: AleaState): PRNG;
+export {};

package/dist/types/src/plugins/random/random.d.ts

@@ -0,0 +1,54 @@
+import type { AleaState } from './random.alea';
+export interface RandomState {
+    seed: string | number;
+    prngstate?: AleaState;
+}
+export interface RandomAPI {
+    D4(): number;
+    D4(diceCount: number): number[];
+    D6(): number;
+    D6(diceCount: number): number[];
+    D10(): number;
+    D10(diceCount: number): number[];
+    D12(): number;
+    D12(diceCount: number): number[];
+    D20(): number;
+    D20(diceCount: number): number[];
+    Die(spotvalue?: number): number;
+    Die(spotvalue: number, diceCount: number): number[];
+    Number(): number;
+    Shuffle<T>(deck: T[]): T[];
+}
+export interface PrivateRandomAPI {
+    _private: {
+        isUsed(): boolean;
+        getState(): RandomState;
+    };
+}
+/**
+ * Random
+ *
+ * Calls that require a pseudorandom number generator.
+ * Uses a seed from ctx, and also persists the PRNG
+ * state in ctx so that moves can stay pure.
+ */
+export declare class Random {
+    state: RandomState;
+    used: boolean;
+    /**
+     * Generates a new seed from the current date / time.
+     */
+    static seed(): string;
+    /**
+     * constructor
+     * @param {object} ctx - The ctx object to initialize from.
+     */
+    constructor(state?: RandomState);
+    isUsed(): boolean;
+    getState(): RandomState;
+    /**
+     * Generate a random number.
+     */
+    _random(): number;
+    api(): RandomAPI & PrivateRandomAPI;
+}

package/dist/types/src/plugins/random/random.test.d.ts

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

package/dist/types/src/server/api.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="koa__router" />
+import type { CorsOptions } from 'cors';
+import type Router from '@koa/router';
+import type { Auth } from './auth';
+import type { Server, Game, StorageAPI } from '../types';
+export declare const configureRouter: ({ router, db, auth, games, uuid, }: {
+    router: Router<any, Server.AppCtx>;
+    auth: Auth;
+    games: Game[];
+    uuid?: () => string;
+    db: StorageAPI.Sync | StorageAPI.Async;
+}) => Router<any, Server.AppCtx>;
+export declare const configureApp: (app: Server.App, router: Router<any, Server.AppCtx>, origins: CorsOptions['origin']) => void;

package/dist/types/src/server/api.test.d.ts

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

package/dist/types/src/server/auth.d.ts

@@ -0,0 +1,38 @@
+import type { Server, PlayerID } from '../types';
+/**
+ * Verifies that a match has metadata and is using credentials.
+ */
+export declare const doesMatchRequireAuthentication: (matchData?: Server.MatchData) => boolean;
+/**
+ * The default `authenticateCredentials` method.
+ * Verifies that the provided credentials match the player’s metadata.
+ */
+export declare const areCredentialsAuthentic: Server.AuthenticateCredentials;
+/**
+ * Extracts a player’s metadata from the match data object.
+ */
+export declare const extractPlayerMetadata: (matchData: Server.MatchData, playerID: PlayerID) => Server.PlayerMetadata;
+/**
+ * Class that provides authentication methods to the lobby server & transport.
+ */
+export declare class Auth {
+    private readonly shouldAuthenticate;
+    private readonly authenticate;
+    /**
+     * Generate credentials string from the Koa context.
+     */
+    readonly generateCredentials: Server.GenerateCredentials;
+    constructor(opts?: {
+        authenticateCredentials?: Server.AuthenticateCredentials;
+        generateCredentials?: Server.GenerateCredentials;
+    });
+    /**
+     * Resolves to true if the provided credentials are valid for the given
+     * metadata and player IDs, or if the match does not require authentication.
+     */
+    authenticateCredentials({ playerID, credentials, metadata, }: {
+        playerID: string;
+        credentials: string | undefined;
+        metadata: Server.MatchData;
+    }): boolean | Promise<boolean>;
+}

package/dist/types/src/server/auth.test.d.ts

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

package/dist/types/src/server/cors.d.ts

@@ -0,0 +1,4 @@
+export declare const Origins: {
+    LOCALHOST: RegExp;
+    LOCALHOST_IN_DEVELOPMENT: boolean | RegExp;
+};

package/dist/types/src/server/cors.test.d.ts

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