@mnbroatch/boardgame.io 0.0.1

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

@@ -0,0 +1,387 @@
+import type { Object } from 'ts-toolbelt';
+import type Koa from 'koa';
+import type { Store as ReduxStore } from 'redux';
+import type * as ActionCreators from './core/action-creators';
+import type { ActionErrorType, UpdateErrorType } from './core/errors';
+import type { Flow } from './core/flow';
+import type { CreateGameReducer } from './core/reducer';
+import type { INVALID_MOVE } from './core/constants';
+import type { GameMethod } from './core/game-methods';
+import type { Auth } from './server/auth';
+import type * as StorageAPI from './server/db/base';
+import type { EventsAPI } from './plugins/plugin-events';
+import type { LogAPI } from './plugins/plugin-log';
+import type { RandomAPI } from './plugins/random/random';
+import type { Operation } from 'rfc6902';
+export type { StorageAPI };
+export declare type AnyFn = (...args: any[]) => any;
+export interface State<G extends any = any> {
+    G: G;
+    ctx: Ctx;
+    deltalog?: Array<LogEntry>;
+    plugins: {
+        [pluginName: string]: PluginState;
+    };
+    _undo: Array<Undo<G>>;
+    _redo: Array<Undo<G>>;
+    _stateID: number;
+}
+export declare type ErrorType = UpdateErrorType | ActionErrorType;
+export interface ActionError {
+    type: ErrorType;
+    payload?: any;
+}
+export interface TransientMetadata {
+    error?: ActionError;
+}
+export declare type ActionResult = any;
+export interface TransientState<G extends any = any> extends State<G> {
+    transients?: TransientMetadata;
+}
+export declare type PartialGameState = Pick<State, 'G' | 'ctx' | 'plugins'>;
+export declare type StageName = string;
+export declare type PlayerID = string;
+export declare type StageArg = StageName | {
+    stage?: StageName;
+    /** @deprecated Use `minMoves` and `maxMoves` instead. */
+    moveLimit?: number;
+    minMoves?: number;
+    maxMoves?: number;
+};
+export declare type ActivePlayersArg = PlayerID[] | {
+    currentPlayer?: StageArg;
+    others?: StageArg;
+    all?: StageArg;
+    value?: Record<PlayerID, StageArg>;
+    minMoves?: number;
+    maxMoves?: number;
+    /** @deprecated Use `minMoves` and `maxMoves` instead. */
+    moveLimit?: number;
+    revert?: boolean;
+    next?: ActivePlayersArg;
+};
+export interface ActivePlayers {
+    [playerID: string]: StageName;
+}
+export interface Ctx {
+    numPlayers: number;
+    playOrder: Array<PlayerID>;
+    playOrderPos: number;
+    activePlayers: null | ActivePlayers;
+    currentPlayer: PlayerID;
+    numMoves?: number;
+    gameover?: any;
+    turn: number;
+    phase: string;
+    _activePlayersMinMoves?: Record<PlayerID, number>;
+    _activePlayersMaxMoves?: Record<PlayerID, number>;
+    _activePlayersNumMoves?: Record<PlayerID, number>;
+    _prevActivePlayers?: Array<{
+        activePlayers: null | ActivePlayers;
+        _activePlayersMinMoves?: Record<PlayerID, number>;
+        _activePlayersMaxMoves?: Record<PlayerID, number>;
+        _activePlayersNumMoves?: Record<PlayerID, number>;
+    }>;
+    _nextActivePlayers?: ActivePlayersArg;
+    _random?: {
+        seed: string | number;
+    };
+}
+export interface DefaultPluginAPIs {
+    events: EventsAPI;
+    log: LogAPI;
+    random: RandomAPI;
+}
+export interface PluginState {
+    data: any;
+    api?: any;
+}
+export interface LogEntry {
+    action: ActionShape.MakeMove | ActionShape.GameEvent | ActionShape.Undo | ActionShape.Redo;
+    _stateID: number;
+    turn: number;
+    phase: string;
+    redact?: boolean;
+    automatic?: boolean;
+    metadata?: any;
+    patch?: Operation[];
+}
+export interface PluginContext<API extends any = any, Data extends any = any, G extends any = any> {
+    G: G;
+    ctx: Ctx;
+    game: Game;
+    api: API;
+    data: Data;
+}
+export interface Plugin<API extends any = any, Data extends any = any, G extends any = any> {
+    name: string;
+    noClient?: (context: PluginContext<API, Data, G>) => boolean;
+    setup?: (setupCtx: {
+        G: G;
+        ctx: Ctx;
+        game: Game<G>;
+    }) => Data;
+    isInvalid?: (context: Omit<PluginContext<API, Data, G>, 'api'>) => false | string;
+    action?: (data: Data, payload: ActionShape.Plugin['payload']) => Data;
+    api?: (context: {
+        G: G;
+        ctx: Ctx;
+        game: Game<G>;
+        data: Data;
+        playerID?: PlayerID;
+    }) => API;
+    flush?: (context: PluginContext<API, Data, G>) => Data;
+    dangerouslyFlushRawState?: (flushCtx: {
+        state: State<G>;
+        game: Game<G>;
+        api: API;
+        data: Data;
+    }) => State<G>;
+    fnWrap?: (moveOrHook: (context: FnContext<G>, ...args: any[]) => any, methodType: GameMethod) => (context: FnContext<G>, ...args: any[]) => any;
+    playerView?: (context: {
+        G: G;
+        ctx: Ctx;
+        game: Game<G>;
+        data: Data;
+        playerID?: PlayerID | null;
+    }) => any;
+}
+export declare type FnContext<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> = PluginAPIs & DefaultPluginAPIs & {
+    G: G;
+    ctx: Ctx;
+};
+export declare type MoveFn<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> = (context: FnContext<G, PluginAPIs> & {
+    playerID: PlayerID;
+}, ...args: any[]) => void | G | typeof INVALID_MOVE;
+export interface LongFormMove<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    move: MoveFn<G, PluginAPIs>;
+    redact?: boolean | ((context: {
+        G: G;
+        ctx: Ctx;
+    }) => boolean);
+    noLimit?: boolean;
+    client?: boolean;
+    undoable?: boolean | ((context: {
+        G: G;
+        ctx: Ctx;
+    }) => boolean);
+    ignoreStaleStateID?: boolean;
+}
+export declare type Move<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> = MoveFn<G, PluginAPIs> | LongFormMove<G, PluginAPIs>;
+export interface MoveMap<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    [moveName: string]: Move<G, PluginAPIs>;
+}
+export interface PhaseConfig<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    start?: boolean;
+    next?: ((context: FnContext<G, PluginAPIs>) => string | void) | string;
+    onBegin?: (context: FnContext<G, PluginAPIs>) => void | G;
+    onEnd?: (context: FnContext<G, PluginAPIs>) => void | G;
+    endIf?: (context: FnContext<G, PluginAPIs>) => boolean | void | {
+        next: string;
+    };
+    moves?: MoveMap<G, PluginAPIs>;
+    turn?: TurnConfig<G, PluginAPIs>;
+    wrapped?: {
+        endIf?: (state: State<G>) => boolean | void | {
+            next: string;
+        };
+        onBegin?: (state: State<G>) => void | G;
+        onEnd?: (state: State<G>) => void | G;
+        next?: (state: State<G>) => string | void;
+    };
+}
+export interface StageConfig<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    moves?: MoveMap<G, PluginAPIs>;
+    next?: string;
+}
+export interface StageMap<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    [stageName: string]: StageConfig<G, PluginAPIs>;
+}
+export interface TurnOrderConfig<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    first: (context: FnContext<G, PluginAPIs>) => number;
+    next: (context: FnContext<G, PluginAPIs>) => number | undefined;
+    playOrder?: (context: FnContext<G, PluginAPIs>) => PlayerID[];
+}
+export interface TurnConfig<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    activePlayers?: ActivePlayersArg;
+    minMoves?: number;
+    maxMoves?: number;
+    /** @deprecated Use `minMoves` and `maxMoves` instead. */
+    moveLimit?: number;
+    onBegin?: (context: FnContext<G, PluginAPIs>) => void | G;
+    onEnd?: (context: FnContext<G, PluginAPIs>) => void | G;
+    endIf?: (context: FnContext<G, PluginAPIs>) => boolean | void | {
+        next: PlayerID;
+    };
+    onMove?: (context: FnContext<G, PluginAPIs> & {
+        playerID: PlayerID;
+    }) => void | G;
+    stages?: StageMap<G, PluginAPIs>;
+    order?: TurnOrderConfig<G, PluginAPIs>;
+    wrapped?: {
+        endIf?: (state: State<G>) => boolean | void | {
+            next: PlayerID;
+        };
+        onBegin?: (state: State<G>) => void | G;
+        onEnd?: (state: State<G>) => void | G;
+        onMove?: (state: State<G> & {
+            playerID: PlayerID;
+        }) => void | G;
+    };
+}
+export interface PhaseMap<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>> {
+    [phaseName: string]: PhaseConfig<G, PluginAPIs>;
+}
+export declare type AiEnumerate = Array<{
+    event: string;
+    args?: any[];
+} | {
+    move: string;
+    args?: any[];
+} | ActionShape.MakeMove | ActionShape.GameEvent>;
+export interface Game<G extends any = any, PluginAPIs extends Record<string, unknown> = Record<string, unknown>, SetupData extends any = any> {
+    name?: string;
+    minPlayers?: number;
+    maxPlayers?: number;
+    deltaState?: boolean;
+    disableUndo?: boolean;
+    seed?: string | number;
+    setup?: (context: PluginAPIs & DefaultPluginAPIs & {
+        ctx: Ctx;
+    }, setupData?: SetupData) => G;
+    validateSetupData?: (setupData: SetupData | undefined, numPlayers: number) => string | undefined;
+    moves?: MoveMap<G, PluginAPIs>;
+    phases?: PhaseMap<G, PluginAPIs>;
+    turn?: TurnConfig<G, PluginAPIs>;
+    events?: {
+        endGame?: boolean;
+        endPhase?: boolean;
+        endTurn?: boolean;
+        setPhase?: boolean;
+        endStage?: boolean;
+        setStage?: boolean;
+        pass?: boolean;
+        setActivePlayers?: boolean;
+    };
+    endIf?: (context: FnContext<G, PluginAPIs>) => any;
+    onEnd?: (context: FnContext<G, PluginAPIs>) => void | G;
+    playerView?: (context: {
+        G: G;
+        ctx: Ctx;
+        playerID: PlayerID | null;
+    }) => any;
+    plugins?: Array<Plugin<any, any, G>>;
+    ai?: {
+        enumerate: (G: G, ctx: Ctx, playerID: PlayerID) => AiEnumerate;
+    };
+    processMove?: (state: State<G>, action: ActionPayload.MakeMove) => State<G> | typeof INVALID_MOVE;
+    flow?: ReturnType<typeof Flow>;
+}
+export declare type Undo<G extends any = any> = {
+    G: G;
+    ctx: Ctx;
+    plugins: {
+        [pluginName: string]: PluginState;
+    };
+    moveType?: string;
+    playerID?: PlayerID;
+};
+export declare namespace Server {
+    type GenerateCredentials = (ctx: Koa.DefaultContext) => Promise<string> | string;
+    type AuthenticateCredentials = (credentials: string, playerMetadata: PlayerMetadata) => Promise<boolean> | boolean;
+    type PlayerMetadata = {
+        id: number;
+        name?: string;
+        credentials?: string;
+        data?: any;
+        isConnected?: boolean;
+    };
+    interface MatchData {
+        gameName: string;
+        players: {
+            [id: number]: PlayerMetadata;
+        };
+        setupData?: any;
+        gameover?: any;
+        nextMatchID?: string;
+        unlisted?: boolean;
+        createdAt: number;
+        updatedAt: number;
+    }
+    type AppCtx = Koa.DefaultContext & {
+        db: StorageAPI.Async | StorageAPI.Sync;
+        auth: Auth;
+    };
+    type App = Koa<Koa.DefaultState, AppCtx>;
+}
+export declare namespace LobbyAPI {
+    export type GameList = string[];
+    type PublicPlayerMetadata = Omit<Server.PlayerMetadata, 'credentials'>;
+    export type Match = Omit<Server.MatchData, 'players'> & {
+        matchID: string;
+        players: PublicPlayerMetadata[];
+    };
+    export interface MatchList {
+        matches: Match[];
+    }
+    export interface CreatedMatch {
+        matchID: string;
+    }
+    export interface JoinedMatch {
+        playerID: string;
+        playerCredentials: string;
+    }
+    export interface NextMatch {
+        nextMatchID: string;
+    }
+    export {};
+}
+export declare type Reducer = ReturnType<typeof CreateGameReducer>;
+export declare type Store = ReduxStore<State, ActionShape.Any>;
+export declare namespace CredentialedActionShape {
+    type MakeMove = ReturnType<typeof ActionCreators.makeMove>;
+    type GameEvent = ReturnType<typeof ActionCreators.gameEvent>;
+    type Plugin = ReturnType<typeof ActionCreators.plugin>;
+    type AutomaticGameEvent = ReturnType<typeof ActionCreators.automaticGameEvent>;
+    type Undo = ReturnType<typeof ActionCreators.undo>;
+    type Redo = ReturnType<typeof ActionCreators.redo>;
+    type Any = MakeMove | GameEvent | AutomaticGameEvent | Undo | Redo | Plugin;
+}
+export declare namespace ActionShape {
+    type StripCredentials<T extends CredentialedActionShape.Any> = Object.P.Omit<T, ['payload', 'credentials']>;
+    export type MakeMove = StripCredentials<CredentialedActionShape.MakeMove>;
+    export type GameEvent = StripCredentials<CredentialedActionShape.GameEvent>;
+    export type Plugin = StripCredentials<CredentialedActionShape.Plugin>;
+    export type AutomaticGameEvent = StripCredentials<CredentialedActionShape.AutomaticGameEvent>;
+    export type Sync = ReturnType<typeof ActionCreators.sync>;
+    export type Update = ReturnType<typeof ActionCreators.update>;
+    export type Patch = ReturnType<typeof ActionCreators.patch>;
+    export type Reset = ReturnType<typeof ActionCreators.reset>;
+    export type Undo = StripCredentials<CredentialedActionShape.Undo>;
+    export type Redo = StripCredentials<CredentialedActionShape.Redo>;
+    export type StripTransients = ReturnType<typeof ActionCreators.stripTransients>;
+    export type Any = MakeMove | GameEvent | AutomaticGameEvent | Sync | Update | Patch | Reset | Undo | Redo | Plugin | StripTransients;
+    export {};
+}
+export declare namespace ActionPayload {
+    type GetPayload<T extends ActionShape.Any> = Object.At<T, 'payload'>;
+    export type MakeMove = GetPayload<ActionShape.MakeMove>;
+    export type GameEvent = GetPayload<ActionShape.GameEvent>;
+    export {};
+}
+export declare type FilteredMetadata = {
+    id: number;
+    name?: string;
+    isConnected?: boolean;
+}[];
+export interface SyncInfo {
+    state: State;
+    filteredMetadata: FilteredMetadata;
+    initialState: State;
+    log: LogEntry[];
+}
+export interface ChatMessage {
+    id: string;
+    sender: PlayerID;
+    payload: any;
+}

package/internal/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "boardgame.io/internal",
+  "private": true,
+  "types": "../dist/types/packages/internal.d.ts",
+  "main": "../dist/cjs/internal.js",
+  "module": "../dist/esm/internal.js"
+}

package/master/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "boardgame.io/master",
+  "private": true,
+  "types": "../dist/types/packages/master.d.ts",
+  "main": "../dist/cjs/master.js",
+  "module": "../dist/esm/master.js"
+}

package/multiplayer/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "boardgame.io/multiplayer",
+  "private": true,
+  "types": "../dist/types/packages/multiplayer.d.ts",
+  "main": "../dist/cjs/multiplayer.js",
+  "module": "../dist/esm/multiplayer.js"
+}

package/package.json

@@ -0,0 +1,211 @@
+{
+  "name": "@mnbroatch/boardgame.io",
+  "version": "0.0.1",
+  "description": "library for turn-based games",
+  "repository": "https://github.com/boardgameio/boardgame.io",
+  "scripts": {
+    "prestart": "run-p examples:install build",
+    "start": "run-p dev:server dev:client",
+    "predev": "npm run examples:install",
+    "dev": "run-p build:watch dev:server dev:client",
+    "dev:client": "node scripts/dev-client.js",
+    "dev:server": "cross-env NODE_ENV=development nodemon -w src -w examples -e js,ts --exec babel-node --extensions \".ts,.js\" --ignore \"src/**/*.test.ts\" --presets @babel/preset-env examples/react-web/server.js",
+    "build": "cross-env BABEL_ENV=rollup rollup --config rollup.config.js  --silent",
+    "build:watch": "cross-env BABEL_ENV=rollup rollup -w --config rollup.config.js",
+    "benchmark": "babel-node --extensions .ts,.js --presets @babel/preset-env,@babel/preset-typescript benchmark/index.js",
+    "docs": "docsify serve docs",
+    "examples": "npm run start",
+    "examples:install": "node scripts/install-examples.js",
+    "pretest": "npm run lint",
+    "test": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm test -- --watch",
+    "test:coverage": "npm test -- --coverage --collectCoverageFrom=\"src/**\"",
+    "test:coveralls": "coveralls < coverage/lcov.info",
+    "test:integration": "node ./scripts/integration.js",
+    "ts": "tsc --noEmit",
+    "ts:watch": "tsc --noEmit --watch",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "prepublishOnly": "npm run clean",
+    "proxydirs": "node scripts/proxy-dirs.js",
+    "prepack": "run-s build proxydirs",
+    "postpack": "npm run clean",
+    "prettier": "prettier --write \"{examples,src,benchmark}/**/*.{ts,tsx,js,jsx,css,md}\"",
+    "changelog": "node ./scripts/changelog.js",
+    "clean": "node ./scripts/clean.js"
+  },
+  "sideEffects": false,
+  "main": "dist/boardgameio.js",
+  "unpkg": "dist/boardgameio.min.js",
+  "module": "dist/boardgameio.es.js",
+  "types": "dist/types/src/types.d.ts",
+  "files": [
+    "src",
+    "dist/boardgameio.js",
+    "dist/boardgameio.min.js",
+    "dist/boardgameio.es.js",
+    "dist/esm",
+    "dist/cjs",
+    "dist/types",
+    "client",
+    "core",
+    "debug",
+    "react",
+    "react-native",
+    "server",
+    "ai",
+    "plugins",
+    "master",
+    "multiplayer",
+    "internal",
+    "testing"
+  ],
+  "keywords": [
+    "board games",
+    "card games",
+    "tabletop games",
+    "game engine"
+  ],
+  "engines": {
+    "node": ">=10.0",
+    "npm": ">=6.0"
+  },
+  "author": "nicolodavis@gmail.com",
+  "license": "MIT",
+  "funding": [
+    "https://github.com/boardgameio/boardgame.io?sponsor=1",
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/boardgameio"
+    }
+  ],
+  "devDependencies": {
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.0",
+    "@babel/node": "^7.16.0",
+    "@babel/plugin-proposal-class-properties": "^7.16.0",
+    "@babel/plugin-proposal-object-rest-spread": "^7.16.0",
+    "@babel/plugin-transform-modules-commonjs": "^7.16.0",
+    "@babel/preset-env": "^7.16.0",
+    "@babel/preset-react": "^7.16.0",
+    "@babel/preset-typescript": "^7.16.0",
+    "@testing-library/jest-dom": "^5.14.1",
+    "@testing-library/svelte": "^3.0.3",
+    "@types/enzyme": "^3.10.9",
+    "@types/jest": "^27.0.1",
+    "@types/koa__cors": "^3.0.3",
+    "@types/node": "^14.0.24",
+    "@types/react": "^16.14.11",
+    "@types/react-dom": "^16.9.14",
+    "@types/supertest": "^2.0.11",
+    "@typescript-eslint/eslint-plugin": "^4.29.3",
+    "@typescript-eslint/parser": "^4.29.3",
+    "babel-plugin-module-resolver": "^4.1.0",
+    "benchmark": "^2.1.4",
+    "cross-env": "^7.0.3",
+    "docsify-cli": "^4.4.4",
+    "enzyme": "^3.11.0",
+    "enzyme-adapter-react-16": "^1.15.6",
+    "eslint": "^7.31.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-jest": "^24.4.0",
+    "eslint-plugin-prettier": "^3.4.0",
+    "eslint-plugin-react": "^7.24.0",
+    "eslint-plugin-unicorn": "^30.0.0",
+    "husky": "^4.3.8",
+    "identity-obj-proxy": "^3.0.0",
+    "jest": "^27.1.0",
+    "jest-date-mock": "^1.0.8",
+    "jest-transform-svelte": "^2.1.1",
+    "lint-staged": "^10.5.4",
+    "node-persist": "^3.1.0",
+    "nodemon": "^2.0.12",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.3.2",
+    "raf": "^3.4.1",
+    "react": "^16.14.0",
+    "react-dom": "^16.14.0",
+    "rollup": "^2.79.2",
+    "rollup-plugin-babel": "^4.2.0",
+    "rollup-plugin-commonjs": "^9.2.0",
+    "rollup-plugin-filesize": "^6.0.0",
+    "rollup-plugin-node-builtins": "^2.1.2",
+    "rollup-plugin-node-resolve": "^4.0.0",
+    "rollup-plugin-replace": "^2.1.0",
+    "rollup-plugin-svelte": "^6.1.1",
+    "rollup-plugin-terser": "^5.3.0",
+    "rollup-plugin-typescript2": "^0.22.0",
+    "shelljs": "^0.8.4",
+    "supertest": "^3.1.0",
+    "svelte-icons": "^2.1.0",
+    "tempy": "^1.0.1",
+    "ts-jest": "^27.0.5",
+    "ts-transformer-imports": "^0.4.3",
+    "ttypescript": "^1.5.12",
+    "typescript": "^3.8.2"
+  },
+  "dependencies": {
+    "@koa/cors": "^3.1.0",
+    "@koa/router": "^10.1.1",
+    "@types/koa": "^2.13.4",
+    "@types/koa__router": "^8.0.8",
+    "flatted": "^3.2.1",
+    "immer": "^9.0.5",
+    "koa": "^2.13.3",
+    "koa-body": "^5.0.0",
+    "koa-socket-2": "^2.0.0",
+    "lodash.isplainobject": "^4.0.6",
+    "nanoid": "^3.1.30",
+    "p-queue": "^6.6.2",
+    "prop-types": "^15.5.10",
+    "react-cookies": "^0.1.0",
+    "redux": "^4.1.0",
+    "rfc6902": "^5.0.0",
+    "setimmediate": "^1.0.5",
+    "socket.io": "^4.5.0",
+    "socket.io-client": "^4.1.3",
+    "svelte": "^3.41.0",
+    "svelte-json-tree-auto": "^0.1.0",
+    "ts-toolbelt": "^6.3.6"
+  },
+  "jest": {
+    "preset": "ts-jest/presets/js-with-babel",
+    "testEnvironment": "jsdom",
+    "moduleNameMapper": {
+      "\\.(css)$": "identity-obj-proxy",
+      "\\.(svg)$": "<rootDir>/.empty_module.js",
+      "svelte-json-tree-auto": "<rootDir>/src/client/debug/tests/JSONTree.mock.svelte"
+    },
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "src/client/transport/dummy",
+      "src/client/debug/.*",
+      "src/types.ts"
+    ],
+    "setupFiles": [
+      "raf/polyfill",
+      "jest-date-mock"
+    ],
+    "setupFilesAfterEnv": [
+      "@testing-library/jest-dom/extend-expect"
+    ],
+    "transform": {
+      "^.+\\.svelte$": "jest-transform-svelte"
+    },
+    "transformIgnorePatterns": [
+      "node_modules/(?!(boardgame.io|flatted|svelte-icons)/)"
+    ],
+    "testPathIgnorePatterns": [
+      "examples/",
+      "integration/",
+      "node_modules/",
+      ".npm/"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged",
+      "pre-push": "npm run test:coverage"
+    }
+  }
+}

package/plugins/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "boardgame.io/plugins",
+  "private": true,
+  "types": "../dist/types/packages/plugins.d.ts",
+  "main": "../dist/cjs/plugins.js",
+  "module": "../dist/esm/plugins.js"
+}

package/react/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "boardgame.io/react",
+  "private": true,
+  "types": "../dist/types/packages/react.d.ts",
+  "main": "../dist/cjs/react.js",
+  "module": "../dist/esm/react.js"
+}

package/react-native/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "boardgame.io/react-native",
+  "private": true,
+  "types": "../dist/types/packages/react-native.d.ts",
+  "main": "../dist/cjs/react-native.js",
+  "module": "../dist/esm/react-native.js"
+}

package/server/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "boardgame.io/server",
+  "private": true,
+  "types": "../dist/types/packages/server.d.ts",
+  "main": "../dist/cjs/server.js"
+}