hypercross
/
boardgame-core
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: hypercross:34cb828f60e4a4d20bd2c93089e1fa99fb70406e
Branches Tags
hypercross:master
..
compare: hypercross:52b6cecd647a39ff8b52acb3f7fb708dad693c87
Branches Tags
hypercross:master

No commits in common. "34cb828f60e4a4d20bd2c93089e1fa99fb70406e" and "52b6cecd647a39ff8b52acb3f7fb708dad693c87" have entirely different histories.
34cb828f60 ... 52b6cecd64

13 changed files with 2996 additions and 3523 deletions
Show Stats Expand all files Collapse all files

6
src/samples/slay-the-spire-like/system/encounter/combat.ts
View File

@ -29,12 +29,6 @@ export function buildCombatState(
}; };
} }
export function buildCombatEncounterState(
data: EncounterData<"minion" | "elite">,
): CombatEncounterState {
return { data, blocked: false };
}
function createEnemyEntities(encounter: EncounterData): EnemyEntity[] { function createEnemyEntities(encounter: EncounterData): EnemyEntity[] {
const enemies: EnemyEntity[] = []; const enemies: EnemyEntity[] = [];
let instanceCounter = 0; let instanceCounter = 0;

100
src/samples/slay-the-spire-like/system/encounter/encounter.ts
View File

@ -1,100 +0,0 @@
import { createGridInventory, placeItem } from "../grid-inventory";
import { GameItemMeta } from "../grid-inventory/types";
import { IDENTITY_TRANSFORM } from "../utils/shape-collision";
import { parseShapeString } from "../utils/parse-shape";
import { EncounterData, EncounterType, ItemData } from "../types";
import type { RNG } from "@/utils/rng";
import type {
CampEncounterState,
CombatEncounterState,
CurioEncounterState,
DialogueEncounterState,
EncounterState,
ShopEncounterState,
} from "./types";
import { buildCombatEncounterState } from "./combat";
import { buildShopEncounterState } from "./shop";
function createCurioItems(allItems: ItemData[], rng: RNG): GameItemMeta[] {
const curioItems: GameItemMeta[] = [];
const rolledIndices = new Set<number>();
for (let i = 0; i < 3 && rolledIndices.size < allItems.length; i++) {
let index: number;
do {
index = rng.nextInt(allItems.length);
} while (rolledIndices.has(index));
rolledIndices.add(index);
const itemData = allItems[index];
const shape = parseShapeString(itemData.shape);
curioItems.push({ itemData, shape });
}
return curioItems;
}
export function buildCurioEncounterState(
data: EncounterData<"curio">,
allItems: ItemData[],
rng: RNG,
): CurioEncounterState {
const items = createCurioItems(allItems, rng);
const inventory = createGridInventory<GameItemMeta>(6, 4);
for (let i = 0; i < items.length; i++) {
const meta = items[i];
placeItem(inventory, {
id: `curio-item-${i}`,
shape: meta.shape,
transform: { ...IDENTITY_TRANSFORM, offset: { x: i, y: 0 } },
meta,
});
}
return { data, items: inventory };
}
export function buildCampEncounterState(
data: EncounterData<"camp">,
): CampEncounterState {
return { data };
}
export function buildDialogueEncounterState(
data: EncounterData<"event">,
): DialogueEncounterState {
return { data, blocked: false };
}
export function buildEncounterState(
data: EncounterData<EncounterType>,
allItems: ItemData[],
rng: RNG,
idCounter: { value: number },
): EncounterState {
switch (data.type) {
case "minion":
case "elite":
return buildCombatEncounterState(
data as EncounterData<"minion" | "elite">,
);
case "shop":
return buildShopEncounterState(
data as EncounterData<"shop">,
allItems,
rng,
idCounter,
);
case "curio":
return buildCurioEncounterState(
data as EncounterData<"curio">,
allItems,
rng,
);
case "camp":
return buildCampEncounterState(data as EncounterData<"camp">);
case "event":
return buildDialogueEncounterState(data as EncounterData<"event">);
}
}

5
src/samples/slay-the-spire-like/system/encounter/index.ts
View File

@ -1,4 +1,3 @@
export { buildCombatState, buildCombatEncounterState } from "./combat";
export { buildShopEncounterState, generateInstanceId } from "./shop";
export { buildEncounterState } from "./encounter";
export { RunState, EncounterState } from "./types"; export { RunState, EncounterState } from "./types";
export { buildCombatState } from "./combat";
export { generateInstanceId } from "./shop";

59
src/samples/slay-the-spire-like/system/encounter/shop.ts
View File

@ -1,63 +1,4 @@
import { createGridInventory, placeItem } from "../grid-inventory";
import { GameItemMeta } from "../grid-inventory/types";
import { IDENTITY_TRANSFORM } from "../utils/shape-collision";
import { parseShapeString } from "../utils/parse-shape";
import { EncounterData, ItemData } from "../types";
import type { RNG } from "@/utils/rng";
import type { ShopEncounterState } from "./types";
export function generateInstanceId(counter: { value: number }): string { export function generateInstanceId(counter: { value: number }): string {
counter.value++; counter.value++;
return `item-${counter.value}`; return `item-${counter.value}`;
} }
function createShopItems(
allItems: ItemData[],
rng: RNG,
): (GameItemMeta & { sellPrice: number })[] {
const shopItems: (GameItemMeta & { sellPrice: number })[] = [];
const rolledIndices = new Set<number>();
for (let i = 0; i < 5 && rolledIndices.size < allItems.length; i++) {
let index: number;
do {
index = rng.nextInt(allItems.length);
} while (rolledIndices.has(index));
rolledIndices.add(index);
const itemData = allItems[index];
const shape = parseShapeString(itemData.shape);
const sellPrice = Math.floor(
(rng.nextInt(5) + rng.nextInt(5) + 1) * 0.2 * itemData.price,
);
shopItems.push({ itemData, shape, sellPrice });
}
return shopItems;
}
export function buildShopEncounterState(
data: EncounterData<"shop">,
allItems: ItemData[],
rng: RNG,
idCounter: { value: number },
): ShopEncounterState {
const items = createShopItems(allItems, rng);
const inventory = createGridInventory<GameItemMeta & { sellPrice: number }>(
6,
4,
);
for (let i = 0; i < items.length; i++) {
const meta = items[i];
placeItem(inventory, {
id: generateInstanceId(idCounter),
shape: meta.shape,
transform: { ...IDENTITY_TRANSFORM, offset: { x: i, y: 0 } },
meta,
});
}
return { data, items: inventory };
}

239
src/samples/tic-tac-toe.ts
View File

@ -1,189 +1,132 @@
import { Part } from "@/core/part"; import {Part} from "boardgame-core";
import { createRegion } from "@/core/region"; import {createRegion} from "boardgame-core";
import { import {createGameCommandRegistry, createPromptDef, IGameContext} from "boardgame-core";
createGameCommandRegistry,
createPromptDef,
IGameContext,
} from "@/core/game";
const BOARD_SIZE = 3; const BOARD_SIZE = 3;
const MAX_TURNS = BOARD_SIZE * BOARD_SIZE; const MAX_TURNS = BOARD_SIZE * BOARD_SIZE;
const WINNING_LINES: number[][][] = [ const WINNING_LINES: number[][][] = [
[ [[0, 0], [0, 1], [0, 2]],
[0, 0], [[1, 0], [1, 1], [1, 2]],
[0, 1], [[2, 0], [2, 1], [2, 2]],
[0, 2], [[0, 0], [1, 0], [2, 0]],
], [[0, 1], [1, 1], [2, 1]],
[ [[0, 2], [1, 2], [2, 2]],
[1, 0], [[0, 0], [1, 1], [2, 2]],
[1, 1], [[0, 2], [1, 1], [2, 0]],
[1, 2],
],
[
[2, 0],
[2, 1],
[2, 2],
],
[
[0, 0],
[1, 0],
[2, 0],
],
[
[0, 1],
[1, 1],
[2, 1],
],
[
[0, 2],
[1, 2],
[2, 2],
],
[
[0, 0],
[1, 1],
[2, 2],
],
[
[0, 2],
[1, 1],
[2, 0],
],
]; ];
export type PlayerType = "X" | "O"; export type PlayerType = 'X' | 'O';
export type WinnerType = PlayerType | "draw" | null; export type WinnerType = PlayerType | 'draw' | null;
export type TicTacToePart = Part<{ player: PlayerType }>; export type TicTacToePart = Part<{ player: PlayerType }>;
export function createInitialState() { export function createInitialState() {
return { return {
board: createRegion("board", [ board: createRegion('board', [
{ name: "x", min: 0, max: BOARD_SIZE - 1 }, { name: 'x', min: 0, max: BOARD_SIZE - 1 },
{ name: "y", min: 0, max: BOARD_SIZE - 1 }, { name: 'y', min: 0, max: BOARD_SIZE - 1 },
]), ]),
parts: {} as Record<string, TicTacToePart>, parts: {} as Record<string, TicTacToePart>,
currentPlayer: "X" as PlayerType, currentPlayer: 'X' as PlayerType,
winner: null as WinnerType, winner: null as WinnerType,
turn: 0, turn: 0,
}; };
} }
export type TicTacToeState = ReturnType<typeof createInitialState>; export type TicTacToeState = ReturnType<typeof createInitialState>;
export type TicTacToeGame = IGameContext<TicTacToeState>; export type TicTacToeGame = IGameContext<TicTacToeState>;
export const registry = createGameCommandRegistry<TicTacToeState>(); export const registry = createGameCommandRegistry<TicTacToeState>();
export const prompts = { export const prompts = {
play: createPromptDef<[PlayerType, number, number]>( play: createPromptDef<[PlayerType, number, number]>(
"play <player> <row:number> <col:number>", 'play <player> <row:number> <col:number>')
), }
};
export async function start(game: TicTacToeGame) { export async function start(game: TicTacToeGame) {
while (true) { while (true) {
const currentPlayer = game.value.currentPlayer; const currentPlayer = game.value.currentPlayer;
const turnNumber = game.value.turn + 1; const turnNumber = game.value.turn + 1;
const turnOutput = await turn(game, currentPlayer, turnNumber); const turnOutput = await turn(game, currentPlayer, turnNumber);
game.produce((state) => { game.produce(state => {
state.winner = turnOutput.winner; state.winner = turnOutput.winner;
if (!state.winner) { if (!state.winner) {
state.currentPlayer = state.currentPlayer === "X" ? "O" : "X"; state.currentPlayer = state.currentPlayer === 'X' ? 'O' : 'X';
state.turn = turnNumber; state.turn = turnNumber;
} }
}); });
if (game.value.winner) break; if (game.value.winner) break;
} }
return game.value; return game.value;
} }
const turn = registry.register({ const turn = registry.register({
schema: "turn <player> <turnNumber:number>", schema: 'turn <player> <turnNumber:number>',
async run(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) { async run(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) {
const { player, row, col } = await game.prompt( const {player, row, col} = await game.prompt(
prompts.play, prompts.play,
(player, row, col) => { (player, row, col) => {
if (player !== turnPlayer) { if (player !== turnPlayer) {
throw `Invalid player: ${player}. Expected ${turnPlayer}.`; throw `Invalid player: ${player}. Expected ${turnPlayer}.`;
} else if (!isValidMove(row, col)) { } else if (!isValidMove(row, col)) {
throw `Invalid position: (${row}, ${col}). Must be between 0 and ${BOARD_SIZE - 1}.`; throw `Invalid position: (${row}, ${col}). Must be between 0 and ${BOARD_SIZE - 1}.`;
} else if (isCellOccupied(game, row, col)) { } else if (isCellOccupied(game, row, col)) {
throw `Cell (${row}, ${col}) is already occupied.`; throw `Cell (${row}, ${col}) is already occupied.`;
} else { } else {
return { player, row, col }; return { player, row, col };
} }
}, },
game.value.currentPlayer, game.value.currentPlayer
); );
placePiece(game, row, col, turnPlayer); placePiece(game, row, col, turnPlayer);
const winner = checkWinner(game); const winner = checkWinner(game);
if (winner) return { winner }; if (winner) return { winner };
if (turnNumber >= MAX_TURNS) return { winner: "draw" as WinnerType }; if (turnNumber >= MAX_TURNS) return { winner: 'draw' as WinnerType };
return { winner: null }; return { winner: null };
}, }
}); });
function isValidMove(row: number, col: number): boolean { function isValidMove(row: number, col: number): boolean {
return ( return !isNaN(row) && !isNaN(col) && row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE;
!isNaN(row) &&
!isNaN(col) &&
row >= 0 &&
row < BOARD_SIZE &&
col >= 0 &&
col < BOARD_SIZE
);
} }
export function isCellOccupied( export function isCellOccupied(host: TicTacToeGame, row: number, col: number): boolean {
host: TicTacToeGame, return !!host.value.board.partMap[`${row},${col}`];
row: number,
col: number,
): boolean {
return !!host.value.board.partMap[`${row},${col}`];
} }
export function hasWinningLine(positions: number[][]): boolean { export function hasWinningLine(positions: number[][]): boolean {
return WINNING_LINES.some((line) => return WINNING_LINES.some(line =>
line.every(([r, c]) => positions.some(([pr, pc]) => pr === r && pc === c)), line.every(([r, c]) =>
); positions.some(([pr, pc]) => pr === r && pc === c)
)
);
} }
export function checkWinner(host: TicTacToeGame): WinnerType { export function checkWinner(host: TicTacToeGame): WinnerType {
const parts = host.value.parts; const parts = host.value.parts;
const partsArray = Object.values(parts); const partsArray = Object.values(parts);
const xPositions = partsArray const xPositions = partsArray.filter((p: TicTacToePart) => p.player === 'X').map((p: TicTacToePart) => p.position);
.filter((p: TicTacToePart) => p.player === "X") const oPositions = partsArray.filter((p: TicTacToePart) => p.player === 'O').map((p: TicTacToePart) => p.position);
.map((p: TicTacToePart) => p.position);
const oPositions = partsArray
.filter((p: TicTacToePart) => p.player === "O")
.map((p: TicTacToePart) => p.position);
if (hasWinningLine(xPositions)) return "X"; if (hasWinningLine(xPositions)) return 'X';
if (hasWinningLine(oPositions)) return "O"; if (hasWinningLine(oPositions)) return 'O';
if (partsArray.length >= MAX_TURNS) return "draw"; if (partsArray.length >= MAX_TURNS) return 'draw';
return null; return null;
} }
export function placePiece( export function placePiece(host: TicTacToeGame, row: number, col: number, player: PlayerType) {
host: TicTacToeGame, const board = host.value.board;
row: number, const moveNumber = Object.keys(host.value.parts).length + 1;
col: number, const piece: TicTacToePart = {
player: PlayerType, regionId: 'board', position: [row, col], player,
) { id: `piece-${player}-${moveNumber}`
const board = host.value.board; }
const moveNumber = Object.keys(host.value.parts).length + 1; host.produce(state => {
const piece: TicTacToePart = { state.parts[piece.id] = piece;
regionId: "board", board.childIds.push(piece.id);
position: [row, col], board.partMap[`${row},${col}`] = piece.id;
player, });
id: `piece-${player}-${moveNumber}`,
};
host.produce((state) => {
state.parts[piece.id] = piece;
board.childIds.push(piece.id);
board.partMap[`${row},${col}`] = piece.id;
});
} }

1141
tests/core/game-host.test.ts
View File

File diff suppressed because it is too large Load Diff

354
tests/core/game.test.ts
View File

@ -1,215 +1,193 @@
import { describe, it, expect } from "vitest"; import { describe, it, expect } from 'vitest';
import { import { createGameContext, createGameCommandRegistry, createPromptDef, IGameContext, PromptDef } from '@/core/game';
createGameContext, import type { PromptEvent, Command } from '@/utils/command';
createGameCommandRegistry,
createPromptDef,
IGameContext,
PromptDef,
} from "@/core/game";
import type {
PromptEvent,
Command,
CommandRunnerContext,
} from "@/utils/command";
type MyState = { type MyState = {
score: number; score: number;
round: number; round: number;
}; };
describe("createGameContext", () => { describe('createGameContext', () => {
it("should create a game context with state", () => { it('should create a game context with state', () => {
const registry = createGameCommandRegistry(); const registry = createGameCommandRegistry();
const ctx = createGameContext(registry); const ctx = createGameContext(registry);
expect(ctx._state).not.toBeNull(); expect(ctx._state).not.toBeNull();
expect(ctx._state.value).toBeDefined(); expect(ctx._state.value).toBeDefined();
});
it("should wire commands to the context", () => {
const registry = createGameCommandRegistry();
const ctx = createGameContext(registry);
expect(ctx._commands).not.toBeNull();
expect(ctx._commands.registry).toBe(registry);
});
it("should accept initial state as an object", () => {
const registry = createGameCommandRegistry<MyState>();
const ctx = createGameContext<MyState>(registry, {
score: 0,
round: 1,
}); });
expect(ctx._state.value.score).toBe(0); it('should wire commands to the context', () => {
expect(ctx._state.value.round).toBe(1); const registry = createGameCommandRegistry();
}); const ctx = createGameContext(registry);
it("should accept initial state as a factory function", () => { expect(ctx._commands).not.toBeNull();
const registry = createGameCommandRegistry<MyState>(); expect(ctx._commands.registry).toBe(registry);
const ctx = createGameContext<MyState>(registry, () => ({
score: 10,
round: 3,
}));
expect(ctx._state.value.score).toBe(10);
expect(ctx._state.value.round).toBe(3);
});
it("should forward prompt events via listener", async () => {
const registry = createGameCommandRegistry();
const ctx = createGameContext(registry);
registry.register("test <value>", async function (_ctx, value) {
return _ctx.prompt(
createPromptDef("prompt <answer>"),
(answer) => answer,
);
}); });
const promptPromise = new Promise<PromptEvent>((resolve) => { it('should accept initial state as an object', () => {
ctx._commands.on("prompt", resolve); const registry = createGameCommandRegistry<MyState>();
}); const ctx = createGameContext<MyState>(registry, {
const runPromise = ctx.run("test hello"); score: 0,
round: 1,
const promptEvent = await promptPromise;
expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe("prompt");
const error = promptEvent.tryCommit({
name: "prompt",
params: ["yes"],
options: {},
flags: {},
});
expect(error).toBeNull();
const result = await runPromise;
expect(result.success).toBe(true);
});
});
describe("createGameCommand", () => {
it("should run a command with access to game context", async () => {
const registry = createGameCommandRegistry<{ marker: string }>();
registry.register("set-marker <id>", async function (ctx, id) {
ctx.produce((state) => {
state.marker = id;
});
return id;
});
const ctx = createGameContext(registry, { marker: "" });
const result = await ctx.run("set-marker board");
if (!result.success) {
console.error("Error:", result.error);
}
expect(result.success).toBe(true);
if (result.success) {
expect(result.result).toBe("board");
}
expect(ctx._state.value.marker).toBe("board");
});
it("should run a typed command with extended context", async () => {
const registry = createGameCommandRegistry<MyState>();
registry.register(
"add-score <amount:number>",
async function (ctx, amount) {
ctx.produce((state) => {
state.score += amount;
}); });
return ctx.value.score;
},
);
const ctx = createGameContext<MyState>(registry, () => ({ expect(ctx._state.value.score).toBe(0);
score: 0, expect(ctx._state.value.round).toBe(1);
round: 1, });
}));
const result = await ctx.run("add-score 5"); it('should accept initial state as a factory function', () => {
expect(result.success).toBe(true); const registry = createGameCommandRegistry<MyState>();
if (result.success) { const ctx = createGameContext<MyState>(registry, () => ({
expect(result.result).toBe(5); score: 10,
} round: 3,
expect(ctx._state.value.score).toBe(5); }));
});
it("should return error for unknown command", async () => { expect(ctx._state.value.score).toBe(10);
const registry = createGameCommandRegistry(); expect(ctx._state.value.round).toBe(3);
const ctx = createGameContext(registry); });
const result = await ctx.run("nonexistent"); it('should forward prompt events via listener', async () => {
expect(result.success).toBe(false); const registry = createGameCommandRegistry();
if (!result.success) { const ctx = createGameContext(registry);
expect(result.error).toContain("nonexistent");
} registry.register('test <value>', async function (_ctx, value) {
}); return this.prompt({schema: 'prompt <answer>'}, () => 'ok');
});
const promptPromise = new Promise<PromptEvent>(resolve => {
ctx._commands.on('prompt', resolve);
});
const runPromise = ctx.run('test hello');
const promptEvent = await promptPromise;
expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe('prompt');
const error = promptEvent.tryCommit({ name: 'prompt', params: ['yes'], options: {}, flags: {} });
expect(error).toBeNull();
const result = await runPromise;
expect(result.success).toBe(true);
});
}); });
describe("createPromptDef", () => { describe('createGameCommand', () => {
it("should create a PromptDef with string schema", () => { it('should run a command with access to game context', async () => {
const promptDef = createPromptDef<[string, number]>( const registry = createGameCommandRegistry<{ marker: string }>();
"play <player> <score:number>",
); registry.register('set-marker <id>', async function (ctx, id) {
ctx.produce(state => {
state.marker = id;
});
return id;
});
expect(promptDef).toBeDefined(); const ctx = createGameContext(registry, { marker: '' });
expect(promptDef.schema.name).toBe("play");
expect(promptDef.schema.params).toHaveLength(2);
expect(promptDef.schema.params[0].name).toBe("player");
expect(promptDef.schema.params[1].name).toBe("score");
});
it("should create a PromptDef with CommandSchema object", () => { const result = await ctx.run('set-marker board');
const schemaObj = { if (!result.success) {
name: "test", console.error('Error:', result.error);
params: [], }
options: {}, expect(result.success).toBe(true);
flags: {}, if (result.success) {
}; expect(result.result).toBe('board');
const promptDef = createPromptDef<[]>(schemaObj); }
expect(ctx._state.value.marker).toBe('board');
expect(promptDef.schema).toEqual(schemaObj);
});
it("should be usable with game.prompt", async () => {
const registry = createGameCommandRegistry<{ score: number }>();
registry.register("test-prompt", async function (ctx) {
const promptDef = createPromptDef<[number]>("input <value:number>");
const result = await ctx.prompt(promptDef, (value) => {
if (value < 0) throw "Value must be positive";
return value;
});
return result;
}); });
const ctx = createGameContext(registry, { score: 0 }); it('should run a typed command with extended context', async () => {
const registry = createGameCommandRegistry<MyState>();
const promptPromise = new Promise<PromptEvent>((resolve) => { registry.register(
ctx._commands.on("prompt", resolve); 'add-score <amount:number>',
async function (ctx, amount) {
ctx.produce(state => {
state.score += amount;
});
return ctx.value.score;
}
);
const ctx = createGameContext<MyState>(registry, () => ({
score: 0,
round: 1,
}));
const result = await ctx.run('add-score 5');
expect(result.success).toBe(true);
if (result.success) {
expect(result.result).toBe(5);
}
expect(ctx._state.value.score).toBe(5);
}); });
const runPromise = ctx.run("test-prompt");
const promptEvent = await promptPromise; it('should return error for unknown command', async () => {
expect(promptEvent.schema.name).toBe("input"); const registry = createGameCommandRegistry();
const ctx = createGameContext(registry);
const error = promptEvent.tryCommit({ const result = await ctx.run('nonexistent');
name: "input", expect(result.success).toBe(false);
params: [42], if (!result.success) {
options: {}, expect(result.error).toContain('nonexistent');
flags: {}, }
});
});
describe('createPromptDef', () => {
it('should create a PromptDef with string schema', () => {
const promptDef = createPromptDef<[string, number]>('play <player> <score:number>');
expect(promptDef).toBeDefined();
expect(promptDef.schema.name).toBe('play');
expect(promptDef.schema.params).toHaveLength(2);
expect(promptDef.schema.params[0].name).toBe('player');
expect(promptDef.schema.params[1].name).toBe('score');
});
it('should create a PromptDef with CommandSchema object', () => {
const schemaObj = {
name: 'test',
params: [],
options: {},
flags: {}
};
const promptDef = createPromptDef<[]>(schemaObj);
expect(promptDef.schema).toEqual(schemaObj);
});
it('should be usable with game.prompt', async () => {
const registry = createGameCommandRegistry<{ score: number }>();
registry.register('test-prompt', async function(ctx) {
const promptDef = createPromptDef<[number]>('input <value:number>');
const result = await ctx.prompt(
promptDef,
(value) => {
if (value < 0) throw 'Value must be positive';
return value;
}
);
return result;
});
const ctx = createGameContext(registry, { score: 0 });
const promptPromise = new Promise<PromptEvent>(resolve => {
ctx._commands.on('prompt', resolve);
});
const runPromise = ctx.run('test-prompt');
const promptEvent = await promptPromise;
expect(promptEvent.schema.name).toBe('input');
const error = promptEvent.tryCommit({ name: 'input', params: [42], options: {}, flags: {} });
expect(error).toBeNull();
const result = await runPromise;
expect(result.success).toBe(true);
if (result.success) {
expect(result.result).toBe(42);
}
}); });
expect(error).toBeNull();
const result = await runPromise;
expect(result.success).toBe(true);
if (result.success) {
expect(result.result).toBe(42);
}
});
}); });

1334
tests/samples/boop.test.ts
View File

File diff suppressed because it is too large Load Diff

584
tests/samples/regicide.test.ts
View File

@ -1,373 +1,353 @@
import { describe, it, expect } from "vitest"; import {createGameContext} from '@/core/game';
import { createGameContext } from "@/core/game"; import {registry} from '@/samples/regicide/commands';
import { registry } from "@/samples/regicide/commands"; import {createInitialState} from '@/samples/regicide/state';
import { createInitialState } from "@/samples/regicide/state";
import { import {
buildEnemyDeck, buildEnemyDeck,
buildTavernDeck, buildTavernDeck,
createAllCards, createAllCards,
createCard, createCard,
createEnemy, createEnemy,
getCardValue, getCardValue,
isEnemyDefeated, isEnemyDefeated
} from "@/samples/regicide/utils"; } from '@/samples/regicide/utils';
import { Mulberry32RNG } from "@/utils/rng"; import {Mulberry32RNG} from '@/utils/rng';
import { import {CARD_VALUES, ENEMY_COUNT, FACE_CARDS, INITIAL_HAND_SIZE} from '@/samples/regicide/constants';
CARD_VALUES, import {PlayerType} from '@/samples/regicide/types';
ENEMY_COUNT,
FACE_CARDS,
INITIAL_HAND_SIZE,
} from "@/samples/regicide/constants";
import { PlayerType } from "@/samples/regicide/types";
describe("Regicide - Utils", () => { describe('Regicide - Utils', () => {
describe("getCardValue", () => { describe('getCardValue', () => {
it("should return correct value for number cards", () => { it('should return correct value for number cards', () => {
expect(getCardValue("A")).toBe(1); expect(getCardValue('A')).toBe(1);
expect(getCardValue("5")).toBe(5); expect(getCardValue('5')).toBe(5);
expect(getCardValue("10")).toBe(10); expect(getCardValue('10')).toBe(10);
});
it('should return correct value for face cards', () => {
expect(getCardValue('J')).toBe(10);
expect(getCardValue('Q')).toBe(15);
expect(getCardValue('K')).toBe(20);
});
}); });
it("should return correct value for face cards", () => { describe('createCard', () => {
expect(getCardValue("J")).toBe(10); it('should create a card with correct properties', () => {
expect(getCardValue("Q")).toBe(15); const card = createCard('spades_A', 'spades', 'A');
expect(getCardValue("K")).toBe(20); expect(card.id).toBe('spades_A');
}); expect(card.suit).toBe('spades');
}); expect(card.rank).toBe('A');
expect(card.value).toBe(1);
describe("createCard", () => { });
it("should create a card with correct properties", () => {
const card = createCard("spades_A", "spades", "A");
expect(card.id).toBe("spades_A");
expect(card.suit).toBe("spades");
expect(card.rank).toBe("A");
expect(card.value).toBe(1);
});
});
describe("createEnemy", () => {
it("should create an enemy with correct HP", () => {
const enemy = createEnemy("enemy_0", "J", "spades");
expect(enemy.rank).toBe("J");
expect(enemy.value).toBe(10);
expect(enemy.hp).toBe(20);
expect(enemy.maxHp).toBe(20);
}); });
it("should create enemy with different values for different ranks", () => { describe('createEnemy', () => {
const jEnemy = createEnemy("enemy_0", "J", "spades"); it('should create an enemy with correct HP', () => {
const qEnemy = createEnemy("enemy_1", "Q", "hearts"); const enemy = createEnemy('enemy_0', 'J', 'spades');
const kEnemy = createEnemy("enemy_2", "K", "diamonds"); expect(enemy.rank).toBe('J');
expect(enemy.value).toBe(10);
expect(enemy.hp).toBe(20);
expect(enemy.maxHp).toBe(20);
});
expect(jEnemy.value).toBe(10); it('should create enemy with different values for different ranks', () => {
expect(qEnemy.value).toBe(15); const jEnemy = createEnemy('enemy_0', 'J', 'spades');
expect(kEnemy.value).toBe(20); const qEnemy = createEnemy('enemy_1', 'Q', 'hearts');
const kEnemy = createEnemy('enemy_2', 'K', 'diamonds');
expect(jEnemy.hp).toBe(20); expect(jEnemy.value).toBe(10);
expect(qEnemy.hp).toBe(30); expect(qEnemy.value).toBe(15);
expect(kEnemy.hp).toBe(40); expect(kEnemy.value).toBe(20);
});
});
describe("createAllCards", () => { expect(jEnemy.hp).toBe(20);
it("should create 52 cards", () => { expect(qEnemy.hp).toBe(30);
const cards = createAllCards(); expect(kEnemy.hp).toBe(40);
expect(Object.keys(cards).length).toBe(52); });
}); });
it("should have all suits and ranks", () => { describe('createAllCards', () => {
const cards = createAllCards(); it('should create 52 cards', () => {
const suits = ["spades", "hearts", "diamonds", "clubs"]; const cards = createAllCards();
const ranks = [ expect(Object.keys(cards).length).toBe(52);
"A", });
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"10",
"J",
"Q",
"K",
];
for (const suit of suits) { it('should have all suits and ranks', () => {
for (const rank of ranks) { const cards = createAllCards();
const id = `${suit}_${rank}`; const suits = ['spades', 'hearts', 'diamonds', 'clubs'];
expect(cards[id]).toBeDefined(); const ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
expect(cards[id].suit).toBe(suit);
expect(cards[id].rank).toBe(rank);
}
}
});
});
describe("buildEnemyDeck", () => { for (const suit of suits) {
it("should create 12 enemies (J/Q/K)", () => { for (const rank of ranks) {
const rng = new Mulberry32RNG(12345); const id = `${suit}_${rank}`;
const deck = buildEnemyDeck(rng); expect(cards[id]).toBeDefined();
expect(deck.length).toBe(12); expect(cards[id].suit).toBe(suit);
expect(cards[id].rank).toBe(rank);
}
}
});
}); });
it("should have J at top, Q in middle, K at bottom", () => { describe('buildEnemyDeck', () => {
const rng = new Mulberry32RNG(12345); it('should create 12 enemies (J/Q/K)', () => {
const deck = buildEnemyDeck(rng); const rng = new Mulberry32RNG(12345);
const deck = buildEnemyDeck(rng);
expect(deck.length).toBe(12);
});
for (let i = 0; i < 4; i++) { it('should have J at top, Q in middle, K at bottom', () => {
expect(deck[i].rank).toBe("J"); const rng = new Mulberry32RNG(12345);
} const deck = buildEnemyDeck(rng);
for (let i = 4; i < 8; i++) { for (let i = 0; i < 4; i++) {
expect(deck[i].rank).toBe("Q"); expect(deck[i].rank).toBe('J');
} }
for (let i = 8; i < 12; i++) { for (let i = 4; i < 8; i++) {
expect(deck[i].rank).toBe("K"); expect(deck[i].rank).toBe('Q');
} }
});
});
describe("buildTavernDeck", () => { for (let i = 8; i < 12; i++) {
it("should create 40 cards (A-10)", () => { expect(deck[i].rank).toBe('K');
const rng = new Mulberry32RNG(12345); }
const deck = buildTavernDeck(rng); });
expect(deck.length).toBe(40);
}); });
it("should not contain face cards", () => { describe('buildTavernDeck', () => {
const rng = new Mulberry32RNG(12345); it('should create 40 cards (A-10)', () => {
const deck = buildTavernDeck(rng); const rng = new Mulberry32RNG(12345);
const deck = buildTavernDeck(rng);
expect(deck.length).toBe(40);
});
for (const card of deck) { it('should not contain face cards', () => {
expect(FACE_CARDS.includes(card.rank)).toBe(false); const rng = new Mulberry32RNG(12345);
} const deck = buildTavernDeck(rng);
});
});
describe("isEnemyDefeated", () => { for (const card of deck) {
it("should return true when enemy HP <= 0", () => { expect(FACE_CARDS.includes(card.rank)).toBe(false);
const enemy = createEnemy("enemy_0", "J", "spades"); }
expect(isEnemyDefeated(enemy)).toBe(false); });
enemy.hp = 0;
expect(isEnemyDefeated(enemy)).toBe(true);
enemy.hp = -5;
expect(isEnemyDefeated(enemy)).toBe(true);
}); });
it("should return false for null enemy", () => { describe('isEnemyDefeated', () => {
expect(isEnemyDefeated(null)).toBe(false); it('should return true when enemy HP <= 0', () => {
const enemy = createEnemy('enemy_0', 'J', 'spades');
expect(isEnemyDefeated(enemy)).toBe(false);
enemy.hp = 0;
expect(isEnemyDefeated(enemy)).toBe(true);
enemy.hp = -5;
expect(isEnemyDefeated(enemy)).toBe(true);
});
it('should return false for null enemy', () => {
expect(isEnemyDefeated(null)).toBe(false);
});
}); });
});
}); });
describe("Regicide - Commands", () => { describe('Regicide - Commands', () => {
function createTestContext() { function createTestContext() {
const initialState = createInitialState(); const initialState = createInitialState();
return createGameContext(registry, initialState); return createGameContext(registry, initialState);
} }
function setupTestGame(game: ReturnType<typeof createTestContext>) { function setupTestGame(game: ReturnType<typeof createTestContext>) {
const cards = createAllCards(); const cards = createAllCards();
const rng = new Mulberry32RNG(12345); const rng = new Mulberry32RNG(12345);
const enemyDeck = buildEnemyDeck(rng); const enemyDeck = buildEnemyDeck(rng);
const tavernDeck = buildTavernDeck(rng); const tavernDeck = buildTavernDeck(rng);
game.produce((state) => { game.produce(state => {
state.cards = cards; state.cards = cards;
state.playerCount = 2; state.playerCount = 2;
state.currentPlayerIndex = 0; state.currentPlayerIndex = 0;
state.enemyDeck = [...enemyDeck]; state.enemyDeck = [...enemyDeck];
state.currentEnemy = { ...enemyDeck[0] }; state.currentEnemy = {...enemyDeck[0]};
for (const card of tavernDeck) { for (const card of tavernDeck) {
state.regions.tavernDeck.childIds.push(card.id); state.regions.tavernDeck.childIds.push(card.id);
} }
for (let i = 0; i < 6; i++) { for (let i = 0; i < 6; i++) {
const card1 = tavernDeck[i]; const card1 = tavernDeck[i];
const card2 = tavernDeck[i + 6]; const card2 = tavernDeck[i + 6];
card1.regionId = "hand_player1"; card1.regionId = 'hand_player1';
card2.regionId = "hand_player2"; card2.regionId = 'hand_player2';
state.playerHands.player1.push(card1.id); state.playerHands.player1.push(card1.id);
state.playerHands.player2.push(card2.id); state.playerHands.player2.push(card2.id);
state.regions.hand_player1.childIds.push(card1.id); state.regions.hand_player1.childIds.push(card1.id);
state.regions.hand_player2.childIds.push(card2.id); state.regions.hand_player2.childIds.push(card2.id);
} }
}); });
} }
describe("play command", () => { describe('play command', () => {
it("should deal damage to current enemy", async () => { it('should deal damage to current enemy', async () => {
const game = createTestContext(); const game = createTestContext();
setupTestGame(game); setupTestGame(game);
const enemyHpBefore = game.value.currentEnemy!.hp; const enemyHpBefore = game.value.currentEnemy!.hp;
const cardId = game.value.playerHands.player1[0]; const cardId = game.value.playerHands.player1[0];
const card = game.value.cards[cardId]; const card = game.value.cards[cardId];
const result = await game.run(`play player1 ${cardId}`); const result = await game.run(`play player1 ${cardId}`);
expect(game.value.currentEnemy!.hp).toBe(enemyHpBefore - card.value); expect(game.value.currentEnemy!.hp).toBe(enemyHpBefore - card.value);
});
it('should double damage for clubs suit', async () => {
const game = createTestContext();
setupTestGame(game);
game.produce(state => {
state.cards['clubs_5'] = createCard('clubs_5', 'clubs', '5');
state.playerHands.player1.push('clubs_5');
state.regions.hand_player1.childIds.push('clubs_5');
});
const clubsCardId = 'clubs_5';
const enemyHpBefore = game.value.currentEnemy!.hp;
const card = game.value.cards[clubsCardId];
await game.run(`play player1 ${clubsCardId}`);
expect(game.value.currentEnemy!.hp).toBe(enemyHpBefore - card.value * 2);
});
}); });
it("should double damage for clubs suit", async () => { describe('pass command', () => {
const game = createTestContext(); it('should allow player to pass', async () => {
setupTestGame(game); const game = createTestContext();
setupTestGame(game);
game.produce((state) => { const result = await game.run('pass player1');
state.cards["clubs_5"] = createCard("clubs_5", "clubs", "5");
state.playerHands.player1.push("clubs_5");
state.regions.hand_player1.childIds.push("clubs_5");
});
const clubsCardId = "clubs_5"; expect(result.success).toBe(true);
const enemyHpBefore = game.value.currentEnemy!.hp; });
const card = game.value.cards[clubsCardId];
await game.run(`play player1 ${clubsCardId}`);
expect(game.value.currentEnemy!.hp).toBe(enemyHpBefore - card.value * 2);
});
});
describe("pass command", () => {
it("should allow player to pass", async () => {
const game = createTestContext();
setupTestGame(game);
const result = await game.run("pass player1");
expect(result.success).toBe(true);
});
});
describe("check-enemy command", () => {
it("should detect defeated enemy and reveal next", async () => {
const game = createTestContext();
setupTestGame(game);
const firstEnemy = game.value.currentEnemy!;
game.produce((state) => {
state.currentEnemy!.hp = 0;
});
await game.run("check-enemy");
expect(game.value.regions.discardPile.childIds).toContain(firstEnemy.id);
expect(game.value.currentEnemy).not.toBe(firstEnemy);
}); });
it("should not defeat enemy if HP > 0", async () => { describe('check-enemy command', () => {
const game = createTestContext(); it('should detect defeated enemy and reveal next', async () => {
setupTestGame(game); const game = createTestContext();
setupTestGame(game);
const currentEnemyId = game.value.currentEnemy!.id; const firstEnemy = game.value.currentEnemy!;
game.produce(state => {
state.currentEnemy!.hp = 0;
});
await game.run("check-enemy"); await game.run('check-enemy');
expect(game.value.currentEnemy!.id).toBe(currentEnemyId); expect(game.value.regions.discardPile.childIds).toContain(firstEnemy.id);
}); expect(game.value.currentEnemy).not.toBe(firstEnemy);
}); });
describe("next-turn command", () => { it('should not defeat enemy if HP > 0', async () => {
it("should switch to next player", async () => { const game = createTestContext();
const game = createTestContext(); setupTestGame(game);
setupTestGame(game);
expect(game.value.currentPlayerIndex).toBe(0); const currentEnemyId = game.value.currentEnemy!.id;
await game.run("next-turn"); await game.run('check-enemy');
expect(game.value.currentPlayerIndex).toBe(1); expect(game.value.currentEnemy!.id).toBe(currentEnemyId);
});
}); });
it("should wrap around to first player", async () => { describe('next-turn command', () => {
const game = createTestContext(); it('should switch to next player', async () => {
setupTestGame(game); const game = createTestContext();
setupTestGame(game);
game.produce((state) => { expect(game.value.currentPlayerIndex).toBe(0);
state.currentPlayerIndex = 1;
});
await game.run("next-turn"); await game.run('next-turn');
expect(game.value.currentPlayerIndex).toBe(0); expect(game.value.currentPlayerIndex).toBe(1);
});
it('should wrap around to first player', async () => {
const game = createTestContext();
setupTestGame(game);
game.produce(state => {
state.currentPlayerIndex = 1;
});
await game.run('next-turn');
expect(game.value.currentPlayerIndex).toBe(0);
});
}); });
});
}); });
describe("Regicide - Game Flow", () => { describe('Regicide - Game Flow', () => {
function createTestContext() { function createTestContext() {
const initialState = createInitialState(); const initialState = createInitialState();
return createGameContext(registry, initialState); return createGameContext(registry, initialState);
} }
it("should complete a full turn cycle", async () => { it('should complete a full turn cycle', async () => {
const game = createTestContext(); const game = createTestContext();
const cards = createAllCards(); const cards = createAllCards();
const rng = new Mulberry32RNG(12345); const rng = new Mulberry32RNG(12345);
const enemyDeck = buildEnemyDeck(rng); const enemyDeck = buildEnemyDeck(rng);
const tavernDeck = buildTavernDeck(rng); const tavernDeck = buildTavernDeck(rng);
game.produce((state) => { game.produce(state => {
state.cards = cards; state.cards = cards;
state.playerCount = 1; state.playerCount = 1;
state.currentPlayerIndex = 0; state.currentPlayerIndex = 0;
state.enemyDeck = [...enemyDeck.slice(1)]; state.enemyDeck = [...enemyDeck.slice(1)];
state.currentEnemy = { ...enemyDeck[0] }; state.currentEnemy = {...enemyDeck[0]};
for (const card of tavernDeck) { for (const card of tavernDeck) {
state.regions.tavernDeck.childIds.push(card.id); state.regions.tavernDeck.childIds.push(card.id);
} }
for (let i = 0; i < 6; i++) { for (let i = 0; i < 6; i++) {
const card = tavernDeck[i]; const card = tavernDeck[i];
card.regionId = "hand_player1"; card.regionId = 'hand_player1';
state.playerHands.player1.push(card.id); state.playerHands.player1.push(card.id);
state.regions.hand_player1.childIds.push(card.id); state.regions.hand_player1.childIds.push(card.id);
} }
});
const cardId = game.value.playerHands.player1[0];
const card = game.value.cards[cardId];
const enemyHpBefore = game.value.currentEnemy!.hp;
await game.run(`play player1 ${cardId}`);
expect(game.value.currentEnemy!.hp).toBeLessThan(enemyHpBefore);
}); });
const cardId = game.value.playerHands.player1[0]; it('should win game when all enemies defeated', async () => {
const card = game.value.cards[cardId]; const game = createTestContext();
const enemyHpBefore = game.value.currentEnemy!.hp;
await game.run(`play player1 ${cardId}`); const cards = createAllCards();
const rng = new Mulberry32RNG(12345);
const tavernDeck = buildTavernDeck(rng);
expect(game.value.currentEnemy!.hp).toBeLessThan(enemyHpBefore); game.produce(state => {
}); state.cards = cards;
state.playerCount = 1;
state.currentPlayerIndex = 0;
state.enemyDeck = [];
state.currentEnemy = null;
it("should win game when all enemies defeated", async () => { for (const card of tavernDeck) {
const game = createTestContext(); state.regions.tavernDeck.childIds.push(card.id);
}
});
const cards = createAllCards(); game.produce(state => {
const rng = new Mulberry32RNG(12345); state.phase = 'victory';
const tavernDeck = buildTavernDeck(rng); state.winner = true;
});
game.produce((state) => { expect(game.value.phase).toBe('victory');
state.cards = cards; expect(game.value.winner).toBe(true);
state.playerCount = 1;
state.currentPlayerIndex = 0;
state.enemyDeck = [];
state.currentEnemy = null;
for (const card of tavernDeck) {
state.regions.tavernDeck.childIds.push(card.id);
}
}); });
game.produce((state) => {
state.phase = "victory";
state.winner = true;
});
expect(game.value.phase).toBe("victory");
expect(game.value.winner).toBe(true);
});
}); });

2
tests/samples/slay-the-spire-like/deck/factory.test.ts
View File

@ -14,7 +14,7 @@ import type {
GridInventory, GridInventory,
InventoryItem, InventoryItem,
} from "@/samples/slay-the-spire-like/system/grid-inventory"; } from "@/samples/slay-the-spire-like/system/grid-inventory";
import type { GameItemMeta } from "@/samples/slay-the-spire-like/system/grid-inventory/types"; import type { GameItemMeta } from "@/samples/slay-the-spire-like/system/encounter/types";
import { IDENTITY_TRANSFORM } from "@/samples/slay-the-spire-like/system/utils/shape-collision"; import { IDENTITY_TRANSFORM } from "@/samples/slay-the-spire-like/system/utils/shape-collision";
import { parseShapeString } from "@/samples/slay-the-spire-like/system/utils/parse-shape"; import { parseShapeString } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
import type { import type {

935
tests/samples/slay-the-spire-like/grid-inventory.test.ts
View File

@ -1,538 +1,485 @@
import { describe, it, expect } from "vitest"; import { describe, it, expect } from 'vitest';
import { parseShapeString } from "@/samples/slay-the-spire-like/system/utils/parse-shape"; import { parseShapeString } from '@/samples/slay-the-spire-like/system/utils/parse-shape';
import { IDENTITY_TRANSFORM } from "@/samples/slay-the-spire-like/system/utils/shape-collision"; import { IDENTITY_TRANSFORM } from '@/samples/slay-the-spire-like/system/utils/shape-collision';
import { import {
createGridInventory, createGridInventory,
placeItem, placeItem,
removeItem, removeItem,
moveItem, moveItem,
rotateItem, rotateItem,
flipItem, flipItem,
getOccupiedCellSet, getOccupiedCellSet,
getItemAtCell, getItemAtCell,
getAdjacentItems, getAdjacentItems,
validatePlacement, validatePlacement,
type GridInventory, type GridInventory,
type InventoryItem, type InventoryItem,
} from "@/samples/slay-the-spire-like/system/grid-inventory"; } from '@/samples/slay-the-spire-like/system/grid-inventory';
/** /**
* Helper: create a test inventory item. * Helper: create a test inventory item.
*/ */
function createTestItem( function createTestItem(id: string, shapeStr: string, transform = IDENTITY_TRANSFORM): InventoryItem {
id: string, const shape = parseShapeString(shapeStr);
shapeStr: string, return {
transform = IDENTITY_TRANSFORM, id,
): InventoryItem<Record<string, never>> { shape,
const shape = parseShapeString(shapeStr); transform: { ...transform },
return { };
id,
shape,
transform: { ...transform },
};
} }
describe("grid-inventory", () => { describe('grid-inventory', () => {
describe("createGridInventory", () => { describe('createGridInventory', () => {
it("should create an empty inventory with correct dimensions", () => { it('should create an empty inventory with correct dimensions', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
expect(inv.width).toBe(6); expect(inv.width).toBe(6);
expect(inv.height).toBe(4); expect(inv.height).toBe(4);
expect(inv.items.size).toBe(0); expect(inv.items.size).toBe(0);
expect(inv.occupiedCells.size).toBe(0); expect(inv.occupiedCells.size).toBe(0);
}); });
});
describe("placeItem", () => {
it("should place a single-cell item", () => {
const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "o");
placeItem(inv, item);
expect(inv.items.size).toBe(1);
expect(inv.items.has("sword")).toBe(true);
expect(inv.occupiedCells.has("0,0")).toBe(true);
}); });
it("should place a multi-cell item", () => { describe('placeItem', () => {
const inv = createGridInventory(6, 4); it('should place a single-cell item', () => {
const item = createTestItem("axe", "oee"); const inv = createGridInventory(6, 4);
placeItem(inv, item); const item = createTestItem('sword', 'o');
placeItem(inv, item);
expect(inv.items.size).toBe(1); expect(inv.items.size).toBe(1);
expect(inv.occupiedCells.size).toBe(3); expect(inv.items.has('sword')).toBe(true);
expect(inv.occupiedCells.has("0,0")).toBe(true); expect(inv.occupiedCells.has('0,0')).toBe(true);
expect(inv.occupiedCells.has("1,0")).toBe(true); });
expect(inv.occupiedCells.has("2,0")).toBe(true);
it('should place a multi-cell item', () => {
const inv = createGridInventory(6, 4);
const item = createTestItem('axe', 'oee');
placeItem(inv, item);
expect(inv.items.size).toBe(1);
expect(inv.occupiedCells.size).toBe(3);
expect(inv.occupiedCells.has('0,0')).toBe(true);
expect(inv.occupiedCells.has('1,0')).toBe(true);
expect(inv.occupiedCells.has('2,0')).toBe(true);
});
it('should place multiple items', () => {
const inv = createGridInventory(6, 4);
const itemA = createTestItem('a', 'o');
const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 0 } });
placeItem(inv, itemA);
placeItem(inv, itemB);
expect(inv.items.size).toBe(2);
expect(inv.occupiedCells.size).toBe(2);
expect(inv.occupiedCells.has('0,0')).toBe(true);
expect(inv.occupiedCells.has('3,0')).toBe(true);
});
}); });
it("should place multiple items", () => { describe('removeItem', () => {
const inv = createGridInventory(6, 4); it('should remove an item and free its cells', () => {
const itemA = createTestItem("a", "o"); const inv = createGridInventory(6, 4);
const itemB = createTestItem("b", "o", { const item = createTestItem('sword', 'oee');
...IDENTITY_TRANSFORM, placeItem(inv, item);
offset: { x: 3, y: 0 },
});
placeItem(inv, itemA);
placeItem(inv, itemB);
expect(inv.items.size).toBe(2); removeItem(inv, 'sword');
expect(inv.occupiedCells.size).toBe(2);
expect(inv.occupiedCells.has("0,0")).toBe(true);
expect(inv.occupiedCells.has("3,0")).toBe(true);
});
});
describe("removeItem", () => { expect(inv.items.size).toBe(0);
it("should remove an item and free its cells", () => { expect(inv.occupiedCells.size).toBe(0);
const inv = createGridInventory(6, 4); });
const item = createTestItem("sword", "oee");
placeItem(inv, item);
removeItem(inv, "sword"); it('should only free the removed item\'s cells', () => {
const inv = createGridInventory(6, 4);
const itemA = createTestItem('a', 'o');
const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
placeItem(inv, itemA);
placeItem(inv, itemB);
expect(inv.items.size).toBe(0); removeItem(inv, 'a');
expect(inv.occupiedCells.size).toBe(0);
expect(inv.items.size).toBe(1);
expect(inv.occupiedCells.size).toBe(1);
expect(inv.occupiedCells.has('0,0')).toBe(false);
expect(inv.occupiedCells.has('2,0')).toBe(true);
});
it('should do nothing for non-existent item', () => {
const inv = createGridInventory(6, 4);
removeItem(inv, 'nonexistent');
expect(inv.items.size).toBe(0);
});
}); });
it("should only free the removed item's cells", () => { describe('validatePlacement', () => {
const inv = createGridInventory(6, 4); it('should return valid for empty board', () => {
const itemA = createTestItem("a", "o"); const inv = createGridInventory(6, 4);
const itemB = createTestItem("b", "o", { const shape = parseShapeString('o');
...IDENTITY_TRANSFORM, const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM);
offset: { x: 2, y: 0 }, expect(result).toEqual({ valid: true });
}); });
placeItem(inv, itemA);
placeItem(inv, itemB);
removeItem(inv, "a"); it('should return invalid for out of bounds', () => {
const inv = createGridInventory(6, 4);
const shape = parseShapeString('o');
const result = validatePlacement(inv, shape, {
...IDENTITY_TRANSFORM,
offset: { x: 6, y: 0 },
});
expect(result).toEqual({ valid: false, reason: '超出边界' });
});
expect(inv.items.size).toBe(1); it('should return invalid for collision with existing item', () => {
expect(inv.occupiedCells.size).toBe(1); const inv = createGridInventory(6, 4);
expect(inv.occupiedCells.has("0,0")).toBe(false); const existing = createTestItem('a', 'oee');
expect(inv.occupiedCells.has("2,0")).toBe(true); placeItem(inv, existing);
const shape = parseShapeString('o');
const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM);
expect(result).toEqual({ valid: false, reason: '与已有物品重叠' });
});
it('should return valid when there is room nearby', () => {
const inv = createGridInventory(6, 4);
const existing = createTestItem('a', 'o');
placeItem(inv, existing);
const shape = parseShapeString('o');
const result = validatePlacement(inv, shape, {
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 0 },
});
expect(result).toEqual({ valid: true });
});
}); });
it("should do nothing for non-existent item", () => { describe('moveItem', () => {
const inv = createGridInventory(6, 4); it('should move item to a new position', () => {
removeItem(inv, "nonexistent"); const inv = createGridInventory(6, 4);
expect(inv.items.size).toBe(0); const item = createTestItem('sword', 'o');
}); placeItem(inv, item);
});
describe("validatePlacement", () => { const result = moveItem(inv, 'sword', {
it("should return valid for empty board", () => { ...IDENTITY_TRANSFORM,
const inv = createGridInventory(6, 4); offset: { x: 5, y: 3 },
const shape = parseShapeString("o"); });
const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM);
expect(result).toEqual({ valid: true }); expect(result).toEqual({ success: true });
expect(inv.occupiedCells.has('0,0')).toBe(false);
expect(inv.occupiedCells.has('5,3')).toBe(true);
expect(item.transform.offset).toEqual({ x: 5, y: 3 });
});
it('should reject move that goes out of bounds', () => {
const inv = createGridInventory(6, 4);
const item = createTestItem('sword', 'o');
placeItem(inv, item);
const result = moveItem(inv, 'sword', {
...IDENTITY_TRANSFORM,
offset: { x: 6, y: 0 },
});
expect(result).toEqual({ success: false, reason: '超出边界' });
expect(inv.occupiedCells.has('0,0')).toBe(true);
expect(item.transform.offset).toEqual({ x: 0, y: 0 });
});
it('should reject move that collides with another item', () => {
const inv = createGridInventory(6, 4);
const itemA = createTestItem('a', 'o');
const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
placeItem(inv, itemA);
placeItem(inv, itemB);
const result = moveItem(inv, 'b', {
...IDENTITY_TRANSFORM,
offset: { x: 0, y: 0 },
});
expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
expect(inv.occupiedCells.has('2,0')).toBe(true);
});
it('should return error for non-existent item', () => {
const inv = createGridInventory(6, 4);
const result = moveItem(inv, 'ghost', IDENTITY_TRANSFORM);
expect(result).toEqual({ success: false, reason: '物品不存在' });
});
it('should move multi-cell item correctly', () => {
const inv = createGridInventory(6, 4);
// oes: cells at (0,0), (1,0), (1,1)
const item = createTestItem('axe', 'oes');
placeItem(inv, item);
const newTransform = { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 1 } };
moveItem(inv, 'axe', newTransform);
// Old cells should be freed
expect(inv.occupiedCells.has('0,0')).toBe(false);
expect(inv.occupiedCells.has('1,0')).toBe(false);
expect(inv.occupiedCells.has('1,1')).toBe(false);
// New cells: (0,0)+offset(3,1)=(3,1), (1,0)+(3,1)=(4,1), (1,1)+(3,1)=(4,2)
expect(inv.occupiedCells.has('3,1')).toBe(true);
expect(inv.occupiedCells.has('4,1')).toBe(true);
expect(inv.occupiedCells.has('4,2')).toBe(true);
});
}); });
it("should return invalid for out of bounds", () => { describe('rotateItem', () => {
const inv = createGridInventory(6, 4); it('should rotate item by 90 degrees', () => {
const shape = parseShapeString("o"); const inv = createGridInventory(6, 4);
const result = validatePlacement(inv, shape, { // Horizontal line: (0,0), (1,0)
...IDENTITY_TRANSFORM, const item = createTestItem('bar', 'oe', {
offset: { x: 6, y: 0 }, ...IDENTITY_TRANSFORM,
}); offset: { x: 0, y: 1 }, // Place away from edge so rotation stays in bounds
expect(result).toEqual({ valid: false, reason: "超出边界" }); });
placeItem(inv, item);
const result = rotateItem(inv, 'bar', 90);
expect(result).toEqual({ success: true });
expect(item.transform.rotation).toBe(90);
});
it('should reject rotation that goes out of bounds', () => {
const inv = createGridInventory(3, 3);
// Item at the edge: place a 2-wide item at x=1
const item = createTestItem('bar', 'oe', {
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 0 },
});
placeItem(inv, item);
// Rotating 90° would make it vertical starting at (1,0), going to (1,-1) -> out of bounds
const result = rotateItem(inv, 'bar', 90);
expect(result).toEqual({ success: false, reason: '超出边界' });
});
it('should reject rotation that collides', () => {
const inv = createGridInventory(4, 4);
const itemA = createTestItem('a', 'o');
const itemB = createTestItem('b', 'oe', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
placeItem(inv, itemA);
placeItem(inv, itemB);
// Rotating b 90° would place cells at (2,0) and (2,-1) -> (2,-1) is out of bounds
// Let's try a different scenario: rotate b 270° -> (2,0) and (2,1) which is fine
// But rotating to collide with a at (0,0)... need item close to a
const itemC = createTestItem('c', 'os', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 0 } });
placeItem(inv, itemC);
// Rotating c 90° would give cells at (1,0) and (0,0) -> collision with a
const result = rotateItem(inv, 'c', 90);
expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
});
it('should return error for non-existent item', () => {
const inv = createGridInventory(6, 4);
const result = rotateItem(inv, 'ghost', 90);
expect(result).toEqual({ success: false, reason: '物品不存在' });
});
}); });
it("should return invalid for collision with existing item", () => { describe('flipItem', () => {
const inv = createGridInventory(6, 4); it('should flip item horizontally', () => {
const existing = createTestItem("a", "oee"); const inv = createGridInventory(6, 4);
placeItem(inv, existing); const item = createTestItem('bar', 'oe');
placeItem(inv, item);
const shape = parseShapeString("o"); const result = flipItem(inv, 'bar', 'x');
const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM);
expect(result).toEqual({ valid: false, reason: "与已有物品重叠" }); expect(result).toEqual({ success: true });
expect(item.transform.flipX).toBe(true);
});
it('should flip item vertically', () => {
const inv = createGridInventory(6, 4);
const item = createTestItem('bar', 'os');
placeItem(inv, item);
const result = flipItem(inv, 'bar', 'y');
expect(result).toEqual({ success: true });
expect(item.transform.flipY).toBe(true);
});
it('should reject flip that causes collision', () => {
// oes local cells: (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0).
// Place flipper at offset (0,2): world cells (0,2),(1,2),(1,3).
// flipY gives local (0,1),(1,1),(1,0) + offset(0,2) = (0,3),(1,3),(1,2) — same cells rearranged.
// Need asymmetric shape where flip changes world position.
// Use oes at offset (0,0): cells (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0).
// Place blocker at (0,1) — which is NOT occupied by oes initially.
const inv = createGridInventory(4, 4);
const blocker = createTestItem('blocker', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 1 } });
// oes at (0,1): cells (0,1),(1,1),(1,2). This overlaps blocker at (0,1)!
// Let me try: blocker at (1,0), flipper at offset (0,2).
// flipper oes at (0,2): (0,2),(1,2),(1,3). blocker at (1,0) — no overlap.
// flipY: local (0,1),(1,1),(1,0) + offset(0,2) = (0,3),(1,3),(1,2). No collision with (1,0).
//
// Simpler: oe shape (width=2, height=1). flipY with height=1 is identity. Use os (width=1, height=2).
// os: (0,0),(0,1). flipY: (0,1),(0,0) — same cells.
// Need width>1 and height>1 asymmetric shape: oes
//
// Place flipper at (0,0): cells (0,0),(1,0),(1,1). Place blocker at (0,1) — but (0,1) is not occupied.
// flipY: (0,1),(1,1),(1,0). (0,1) hits blocker!
const inv2 = createGridInventory(4, 4);
const blocker2 = createTestItem('blocker', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 1 } });
const flipper2 = createTestItem('flipper', 'oes'); // at (0,0): (0,0),(1,0),(1,1)
placeItem(inv2, blocker2);
placeItem(inv2, flipper2);
const result = flipItem(inv2, 'flipper', 'y');
expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
});
it('should return error for non-existent item', () => {
const inv = createGridInventory(6, 4);
const result = flipItem(inv, 'ghost', 'x');
expect(result).toEqual({ success: false, reason: '物品不存在' });
});
}); });
it("should return valid when there is room nearby", () => { describe('getOccupiedCellSet', () => {
const inv = createGridInventory(6, 4); it('should return a copy of occupied cells', () => {
const existing = createTestItem("a", "o"); const inv = createGridInventory(6, 4);
placeItem(inv, existing); const item = createTestItem('a', 'oe');
placeItem(inv, item);
const shape = parseShapeString("o"); const cells = getOccupiedCellSet(inv);
const result = validatePlacement(inv, shape, { expect(cells).toEqual(new Set(['0,0', '1,0']));
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 0 },
});
expect(result).toEqual({ valid: true });
});
});
describe("moveItem", () => { // Mutating the copy should not affect the original
it("should move item to a new position", () => { cells.clear();
const inv = createGridInventory(6, 4); expect(inv.occupiedCells.size).toBe(2);
const item = createTestItem("sword", "o"); });
placeItem(inv, item);
const result = moveItem(inv, "sword", {
...IDENTITY_TRANSFORM,
offset: { x: 5, y: 3 },
});
expect(result).toEqual({ success: true });
expect(inv.occupiedCells.has("0,0")).toBe(false);
expect(inv.occupiedCells.has("5,3")).toBe(true);
expect(item.transform.offset).toEqual({ x: 5, y: 3 });
}); });
it("should reject move that goes out of bounds", () => { describe('getItemAtCell', () => {
const inv = createGridInventory(6, 4); it('should return item at occupied cell', () => {
const item = createTestItem("sword", "o"); const inv = createGridInventory(6, 4);
placeItem(inv, item); const item = createTestItem('sword', 'oee');
placeItem(inv, item);
const result = moveItem(inv, "sword", { const found = getItemAtCell(inv, 1, 0);
...IDENTITY_TRANSFORM, expect(found).toBeDefined();
offset: { x: 6, y: 0 }, expect(found!.id).toBe('sword');
}); });
expect(result).toEqual({ success: false, reason: "超出边界" }); it('should return undefined for empty cell', () => {
expect(inv.occupiedCells.has("0,0")).toBe(true); const inv = createGridInventory(6, 4);
expect(item.transform.offset).toEqual({ x: 0, y: 0 }); const item = createTestItem('sword', 'o');
placeItem(inv, item);
const found = getItemAtCell(inv, 5, 5);
expect(found).toBeUndefined();
});
it('should return correct item when multiple items exist', () => {
const inv = createGridInventory(6, 4);
const itemA = createTestItem('a', 'o');
const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 2 } });
placeItem(inv, itemA);
placeItem(inv, itemB);
expect(getItemAtCell(inv, 0, 0)!.id).toBe('a');
expect(getItemAtCell(inv, 3, 2)!.id).toBe('b');
});
}); });
it("should reject move that collides with another item", () => { describe('getAdjacentItems', () => {
const inv = createGridInventory(6, 4); it('should return orthogonally adjacent items', () => {
const itemA = createTestItem("a", "o"); const inv = createGridInventory(6, 4);
const itemB = createTestItem("b", "o", { const center = createTestItem('center', 'o', {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 2, y: 0 }, offset: { x: 2, y: 2 },
}); });
placeItem(inv, itemA); const top = createTestItem('top', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 1 } });
placeItem(inv, itemB); const left = createTestItem('left', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 2 } });
const right = createTestItem('right', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 2 } });
const bottom = createTestItem('bottom', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 3 } });
const diagonal = createTestItem('diagonal', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 1 } });
const result = moveItem(inv, "b", { placeItem(inv, center);
...IDENTITY_TRANSFORM, placeItem(inv, top);
offset: { x: 0, y: 0 }, placeItem(inv, left);
}); placeItem(inv, right);
placeItem(inv, bottom);
placeItem(inv, diagonal);
expect(result).toEqual({ success: false, reason: "与已有物品重叠" }); const adj = getAdjacentItems(inv, 'center');
expect(inv.occupiedCells.has("2,0")).toBe(true); expect(adj.size).toBe(4);
expect(adj.has('top')).toBe(true);
expect(adj.has('left')).toBe(true);
expect(adj.has('right')).toBe(true);
expect(adj.has('bottom')).toBe(true);
expect(adj.has('diagonal')).toBe(false);
});
it('should return empty for item with no neighbors', () => {
const inv = createGridInventory(6, 4);
const item = createTestItem('alone', 'o');
placeItem(inv, item);
const adj = getAdjacentItems(inv, 'alone');
expect(adj.size).toBe(0);
});
it('should return empty for non-existent item', () => {
const inv = createGridInventory(6, 4);
const adj = getAdjacentItems(inv, 'ghost');
expect(adj.size).toBe(0);
});
it('should handle multi-cell items with multiple adjacencies', () => {
const inv = createGridInventory(6, 4);
// Horizontal bar at (0,0)-(1,0)
const bar = createTestItem('bar', 'oe');
// Item above left cell
const topA = createTestItem('topA', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: -1 } });
// Item above right cell
const topB = createTestItem('topB', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: -1 } });
placeItem(inv, bar);
placeItem(inv, topA);
placeItem(inv, topB);
const adj = getAdjacentItems(inv, 'bar');
expect(adj.size).toBe(2);
expect(adj.has('topA')).toBe(true);
expect(adj.has('topB')).toBe(true);
});
}); });
it("should return error for non-existent item", () => { describe('integration: fill a 4x6 backpack', () => {
const inv = createGridInventory(6, 4); it('should place items fitting a slay-the-spire-like backpack', () => {
const result = moveItem(inv, "ghost", IDENTITY_TRANSFORM); const inv = createGridInventory(4, 6);
expect(result).toEqual({ success: false, reason: "物品不存在" });
// Sword: 1x3 horizontal at (0,0)
const sword = createTestItem('sword', 'oee');
// Shield: 2x2 at (0,1)
const shield = createTestItem('shield', 'oes', {
...IDENTITY_TRANSFORM,
offset: { x: 0, y: 1 },
});
expect(validatePlacement(inv, sword.shape, sword.transform)).toEqual({ valid: true });
placeItem(inv, sword);
expect(validatePlacement(inv, shield.shape, shield.transform)).toEqual({ valid: true });
placeItem(inv, shield);
expect(inv.items.size).toBe(2);
expect(inv.occupiedCells.size).toBe(6); // sword(3) + shield(3)
// Adjacent items should detect each other
const adjSword = getAdjacentItems(inv, 'sword');
expect(adjSword.has('shield')).toBe(true);
const adjShield = getAdjacentItems(inv, 'shield');
expect(adjShield.has('sword')).toBe(true);
});
}); });
it("should move multi-cell item correctly", () => {
const inv = createGridInventory(6, 4);
// oes: cells at (0,0), (1,0), (1,1)
const item = createTestItem("axe", "oes");
placeItem(inv, item);
const newTransform = { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 1 } };
moveItem(inv, "axe", newTransform);
// Old cells should be freed
expect(inv.occupiedCells.has("0,0")).toBe(false);
expect(inv.occupiedCells.has("1,0")).toBe(false);
expect(inv.occupiedCells.has("1,1")).toBe(false);
// New cells: (0,0)+offset(3,1)=(3,1), (1,0)+(3,1)=(4,1), (1,1)+(3,1)=(4,2)
expect(inv.occupiedCells.has("3,1")).toBe(true);
expect(inv.occupiedCells.has("4,1")).toBe(true);
expect(inv.occupiedCells.has("4,2")).toBe(true);
});
});
describe("rotateItem", () => {
it("should rotate item by 90 degrees", () => {
const inv = createGridInventory(6, 4);
// Horizontal line: (0,0), (1,0)
const item = createTestItem("bar", "oe", {
...IDENTITY_TRANSFORM,
offset: { x: 0, y: 1 }, // Place away from edge so rotation stays in bounds
});
placeItem(inv, item);
const result = rotateItem(inv, "bar", 90);
expect(result).toEqual({ success: true });
expect(item.transform.rotation).toBe(90);
});
it("should reject rotation that goes out of bounds", () => {
const inv = createGridInventory(3, 3);
// Item at the edge: place a 2-wide item at x=1
const item = createTestItem("bar", "oe", {
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 0 },
});
placeItem(inv, item);
// Rotating 90° would make it vertical starting at (1,0), going to (1,-1) -> out of bounds
const result = rotateItem(inv, "bar", 90);
expect(result).toEqual({ success: false, reason: "超出边界" });
});
it("should reject rotation that collides", () => {
const inv = createGridInventory(4, 4);
const itemA = createTestItem("a", "o");
const itemB = createTestItem("b", "oe", {
...IDENTITY_TRANSFORM,
offset: { x: 2, y: 0 },
});
placeItem(inv, itemA);
placeItem(inv, itemB);
// Rotating b 90° would place cells at (2,0) and (2,-1) -> (2,-1) is out of bounds
// Let's try a different scenario: rotate b 270° -> (2,0) and (2,1) which is fine
// But rotating to collide with a at (0,0)... need item close to a
const itemC = createTestItem("c", "os", {
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 0 },
});
placeItem(inv, itemC);
// Rotating c 90° would give cells at (1,0) and (0,0) -> collision with a
const result = rotateItem(inv, "c", 90);
expect(result).toEqual({ success: false, reason: "与已有物品重叠" });
});
it("should return error for non-existent item", () => {
const inv = createGridInventory(6, 4);
const result = rotateItem(inv, "ghost", 90);
expect(result).toEqual({ success: false, reason: "物品不存在" });
});
});
describe("flipItem", () => {
it("should flip item horizontally", () => {
const inv = createGridInventory(6, 4);
const item = createTestItem("bar", "oe");
placeItem(inv, item);
const result = flipItem(inv, "bar", "x");
expect(result).toEqual({ success: true });
expect(item.transform.flipX).toBe(true);
});
it("should flip item vertically", () => {
const inv = createGridInventory(6, 4);
const item = createTestItem("bar", "os");
placeItem(inv, item);
const result = flipItem(inv, "bar", "y");
expect(result).toEqual({ success: true });
expect(item.transform.flipY).toBe(true);
});
it("should reject flip that causes collision", () => {
// oes local cells: (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0).
// Place flipper at offset (0,2): world cells (0,2),(1,2),(1,3).
// flipY gives local (0,1),(1,1),(1,0) + offset(0,2) = (0,3),(1,3),(1,2) — same cells rearranged.
// Need asymmetric shape where flip changes world position.
// Use oes at offset (0,0): cells (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0).
// Place blocker at (0,1) — which is NOT occupied by oes initially.
const inv = createGridInventory(4, 4);
const blocker = createTestItem("blocker", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 0, y: 1 },
});
// oes at (0,1): cells (0,1),(1,1),(1,2). This overlaps blocker at (0,1)!
// Let me try: blocker at (1,0), flipper at offset (0,2).
// flipper oes at (0,2): (0,2),(1,2),(1,3). blocker at (1,0) — no overlap.
// flipY: local (0,1),(1,1),(1,0) + offset(0,2) = (0,3),(1,3),(1,2). No collision with (1,0).
//
// Simpler: oe shape (width=2, height=1). flipY with height=1 is identity. Use os (width=1, height=2).
// os: (0,0),(0,1). flipY: (0,1),(0,0) — same cells.
// Need width>1 and height>1 asymmetric shape: oes
//
// Place flipper at (0,0): cells (0,0),(1,0),(1,1). Place blocker at (0,1) — but (0,1) is not occupied.
// flipY: (0,1),(1,1),(1,0). (0,1) hits blocker!
const inv2 = createGridInventory(4, 4);
const blocker2 = createTestItem("blocker", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 0, y: 1 },
});
const flipper2 = createTestItem("flipper", "oes"); // at (0,0): (0,0),(1,0),(1,1)
placeItem(inv2, blocker2);
placeItem(inv2, flipper2);
const result = flipItem(inv2, "flipper", "y");
expect(result).toEqual({ success: false, reason: "与已有物品重叠" });
});
it("should return error for non-existent item", () => {
const inv = createGridInventory(6, 4);
const result = flipItem(inv, "ghost", "x");
expect(result).toEqual({ success: false, reason: "物品不存在" });
});
});
describe("getOccupiedCellSet", () => {
it("should return a copy of occupied cells", () => {
const inv = createGridInventory(6, 4);
const item = createTestItem("a", "oe");
placeItem(inv, item);
const cells = getOccupiedCellSet(inv);
expect(cells).toEqual(new Set(["0,0", "1,0"]));
// Mutating the copy should not affect the original
cells.clear();
expect(inv.occupiedCells.size).toBe(2);
});
});
describe("getItemAtCell", () => {
it("should return item at occupied cell", () => {
const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "oee");
placeItem(inv, item);
const found = getItemAtCell(inv, 1, 0);
expect(found).toBeDefined();
expect(found!.id).toBe("sword");
});
it("should return undefined for empty cell", () => {
const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "o");
placeItem(inv, item);
const found = getItemAtCell(inv, 5, 5);
expect(found).toBeUndefined();
});
it("should return correct item when multiple items exist", () => {
const inv = createGridInventory(6, 4);
const itemA = createTestItem("a", "o");
const itemB = createTestItem("b", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 3, y: 2 },
});
placeItem(inv, itemA);
placeItem(inv, itemB);
expect(getItemAtCell(inv, 0, 0)!.id).toBe("a");
expect(getItemAtCell(inv, 3, 2)!.id).toBe("b");
});
});
describe("getAdjacentItems", () => {
it("should return orthogonally adjacent items", () => {
const inv = createGridInventory(6, 4);
const center = createTestItem("center", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 2, y: 2 },
});
const top = createTestItem("top", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 2, y: 1 },
});
const left = createTestItem("left", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 2 },
});
const right = createTestItem("right", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 3, y: 2 },
});
const bottom = createTestItem("bottom", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 2, y: 3 },
});
const diagonal = createTestItem("diagonal", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 1 },
});
placeItem(inv, center);
placeItem(inv, top);
placeItem(inv, left);
placeItem(inv, right);
placeItem(inv, bottom);
placeItem(inv, diagonal);
const adj = getAdjacentItems(inv, "center");
expect(adj.size).toBe(4);
expect(adj.has("top")).toBe(true);
expect(adj.has("left")).toBe(true);
expect(adj.has("right")).toBe(true);
expect(adj.has("bottom")).toBe(true);
expect(adj.has("diagonal")).toBe(false);
});
it("should return empty for item with no neighbors", () => {
const inv = createGridInventory(6, 4);
const item = createTestItem("alone", "o");
placeItem(inv, item);
const adj = getAdjacentItems(inv, "alone");
expect(adj.size).toBe(0);
});
it("should return empty for non-existent item", () => {
const inv = createGridInventory(6, 4);
const adj = getAdjacentItems(inv, "ghost");
expect(adj.size).toBe(0);
});
it("should handle multi-cell items with multiple adjacencies", () => {
const inv = createGridInventory(6, 4);
// Horizontal bar at (0,0)-(1,0)
const bar = createTestItem("bar", "oe");
// Item above left cell
const topA = createTestItem("topA", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 0, y: -1 },
});
// Item above right cell
const topB = createTestItem("topB", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 1, y: -1 },
});
placeItem(inv, bar);
placeItem(inv, topA);
placeItem(inv, topB);
const adj = getAdjacentItems(inv, "bar");
expect(adj.size).toBe(2);
expect(adj.has("topA")).toBe(true);
expect(adj.has("topB")).toBe(true);
});
});
describe("integration: fill a 4x6 backpack", () => {
it("should place items fitting a slay-the-spire-like backpack", () => {
const inv = createGridInventory(4, 6);
// Sword: 1x3 horizontal at (0,0)
const sword = createTestItem("sword", "oee");
// Shield: 2x2 at (0,1)
const shield = createTestItem("shield", "oes", {
...IDENTITY_TRANSFORM,
offset: { x: 0, y: 1 },
});
expect(validatePlacement(inv, sword.shape, sword.transform)).toEqual({
valid: true,
});
placeItem(inv, sword);
expect(validatePlacement(inv, shield.shape, shield.transform)).toEqual({
valid: true,
});
placeItem(inv, shield);
expect(inv.items.size).toBe(2);
expect(inv.occupiedCells.size).toBe(6); // sword(3) + shield(3)
// Adjacent items should detect each other
const adjSword = getAdjacentItems(inv, "sword");
expect(adjSword.has("shield")).toBe(true);
const adjShield = getAdjacentItems(inv, "shield");
expect(adjShield.has("sword")).toBe(true);
});
});
}); });

977
tests/utils/command-runner.test.ts
View File

File diff suppressed because it is too large Load Diff

783
tests/utils/middleware.test.ts
View File

@ -1,445 +1,436 @@
import { describe, it, expect } from "vitest"; import { describe, it, expect } from 'vitest';
import { import { createMiddlewareChain, type MiddlewareChain } from '@/utils/middleware';
createMiddlewareChain,
type MiddlewareChain,
} from "@/utils/middleware";
describe("createMiddlewareChain", () => { describe('createMiddlewareChain', () => {
describe("basic execution", () => { describe('basic execution', () => {
it("should return context when no middlewares and no fallback", async () => { it('should return context when no middlewares and no fallback', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
const result = await chain.execute({ value: 42 }); const result = await chain.execute({ value: 42 });
expect(result).toEqual({ value: 42 }); expect(result).toEqual({ value: 42 });
});
it('should call fallback when no middlewares', async () => {
const chain = createMiddlewareChain<{ value: number }, string>(
async ctx => `value is ${ctx.value}`
);
const result = await chain.execute({ value: 42 });
expect(result).toBe('value is 42');
});
it('should pass context to fallback', async () => {
const chain = createMiddlewareChain<{ a: number; b: number }, number>(
async ctx => ctx.a + ctx.b
);
const result = await chain.execute({ a: 3, b: 7 });
expect(result).toBe(10);
});
}); });
it("should call fallback when no middlewares", async () => { describe('single middleware', () => {
const chain = createMiddlewareChain<{ value: number }, string>( it('should execute a single middleware', async () => {
async (ctx) => `value is ${ctx.value}`, const chain = createMiddlewareChain<{ count: number }>();
); chain.use(async (ctx, next) => {
const result = await chain.execute({ value: 42 }); ctx.count *= 2;
return next();
});
expect(result).toBe("value is 42"); const result = await chain.execute({ count: 5 });
expect(result.count).toBe(10);
});
it('should allow middleware to modify return value', async () => {
const chain = createMiddlewareChain<{ value: number }, number>(
async ctx => ctx.value
);
chain.use(async (ctx, next) => {
const result = await next();
return result * 2;
});
const result = await chain.execute({ value: 21 });
expect(result).toBe(42);
});
it('should allow middleware to short-circuit without calling next', async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (_ctx, _next) => {
return { value: 999 };
});
const result = await chain.execute({ value: 1 });
expect(result.value).toBe(999);
});
}); });
it("should pass context to fallback", async () => { describe('multiple middlewares', () => {
const chain = createMiddlewareChain<{ a: number; b: number }, number>( it('should execute middlewares in order', async () => {
async (ctx) => ctx.a + ctx.b, const order: number[] = [];
); const chain = createMiddlewareChain<{ value: number }>();
const result = await chain.execute({ a: 3, b: 7 });
expect(result).toBe(10); chain.use(async (_ctx, next) => {
}); order.push(1);
}); const result = await next();
order.push(4);
return result;
});
chain.use(async (_ctx, next) => {
order.push(2);
const result = await next();
order.push(3);
return result;
});
describe("single middleware", () => { await chain.execute({ value: 0 });
it("should execute a single middleware", async () => {
const chain = createMiddlewareChain<{ count: number }>();
chain.use(async (ctx, next) => {
ctx.count *= 2;
return next();
});
const result = await chain.execute({ count: 5 }); expect(order).toEqual([1, 2, 3, 4]);
});
expect(result.count).toBe(10); it('should accumulate modifications through the chain', async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (ctx, next) => {
ctx.value += 1;
return next();
});
chain.use(async (ctx, next) => {
ctx.value *= 2;
return next();
});
chain.use(async (ctx, next) => {
ctx.value += 3;
return next();
});
const result = await chain.execute({ value: 0 });
expect(result.value).toBe(5);
});
it('should allow middleware to modify result on the way back', async () => {
const chain = createMiddlewareChain<{ base: number }, number>(
async ctx => ctx.base
);
chain.use(async (_ctx, next) => {
const result = await next();
return result + 10;
});
chain.use(async (_ctx, next) => {
const result = await next();
return result * 2;
});
const result = await chain.execute({ base: 5 });
expect(result).toBe(20);
});
it('should allow middleware to short-circuit in the middle', async () => {
const executed: number[] = [];
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (_ctx, next) => {
executed.push(1);
return next();
});
chain.use(async () => {
executed.push(2);
return { value: -1 };
});
chain.use(async (_ctx, next) => {
executed.push(3);
return next();
});
const result = await chain.execute({ value: 100 });
expect(result.value).toBe(-1);
expect(executed).toEqual([1, 2]);
});
}); });
it("should allow middleware to modify return value", async () => { describe('nested next calls', () => {
const chain = createMiddlewareChain<{ value: number }, number>( it('should advance index on each next call, skipping remaining middlewares', async () => {
async (ctx) => ctx.value, const chain = createMiddlewareChain<{ counter: number }>();
);
chain.use(async (ctx, next) => {
const result = await next();
return result * 2;
});
const result = await chain.execute({ value: 21 }); chain.use(async (_ctx, next) => {
await next();
await next();
});
expect(result).toBe(42); const result = await chain.execute({ counter: 0 });
expect(result).toBeUndefined();
});
it('should allow middleware to call next conditionally', async () => {
const chain = createMiddlewareChain<{ skip: boolean; value: number }>();
chain.use(async (ctx, next) => {
if (ctx.skip) {
return { value: -1 };
}
return next();
});
chain.use(async (ctx, next) => {
ctx.value += 10;
return next();
});
const resultA = await chain.execute({ skip: true, value: 0 });
const resultB = await chain.execute({ skip: false, value: 0 });
expect(resultA.value).toBe(-1);
expect(resultB.value).toBe(10);
});
it('should handle middleware that awaits next multiple times with a fallback', async () => {
const log: string[] = [];
const chain = createMiddlewareChain<{ value: number }, string[]>(
async _ctx => log
);
chain.use(async (_ctx, next) => {
log.push('before');
await next();
log.push('after-first');
await next();
log.push('after-second');
return log;
});
chain.use(async (_ctx, next) => {
log.push('mw2');
return next();
});
const result = await chain.execute({ value: 0 });
expect(result).toEqual(['before', 'mw2', 'after-first', 'after-second']);
});
it('should return fallback result on second next call when no more middlewares remain', async () => {
const chain = createMiddlewareChain<{ value: number }, number>(
async ctx => ctx.value * 10
);
chain.use(async (_ctx, next) => {
await next();
return await next();
});
chain.use(async (_ctx, next) => {
return next();
});
const result = await chain.execute({ value: 5 });
expect(result).toBe(50);
});
it('should return fallback result on second next call when no more middlewares remain', async () => {
const chain = createMiddlewareChain<{ value: number }, number>(
async ctx => ctx.value * 10
);
chain.use(async (_ctx, next) => {
await next();
return await next();
});
chain.use(async (_ctx, next) => {
return next();
});
const result = await chain.execute({ value: 5 });
expect(result).toBe(50);
});
}); });
it("should allow middleware to short-circuit without calling next", async () => { describe('async behavior', () => {
const chain = createMiddlewareChain<{ value: number }>(); it('should handle async middlewares', async () => {
chain.use(async (_ctx, _next) => { const chain = createMiddlewareChain<{ value: number }>();
return { value: 999 };
});
const result = await chain.execute({ value: 1 }); chain.use(async (ctx, next) => {
await new Promise(resolve => setTimeout(resolve, 10));
ctx.value += 1;
return next();
});
chain.use(async (ctx, next) => {
await new Promise(resolve => setTimeout(resolve, 10));
ctx.value += 2;
return next();
});
expect(result.value).toBe(999); const result = await chain.execute({ value: 0 });
});
});
describe("multiple middlewares", () => { expect(result.value).toBe(3);
it("should execute middlewares in order", async () => { });
const order: number[] = [];
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (_ctx, next) => { it('should handle async fallback', async () => {
order.push(1); const chain = createMiddlewareChain<{ value: number }, number>(
const result = await next(); async ctx => {
order.push(4); await new Promise(resolve => setTimeout(resolve, 10));
return result; return ctx.value * 10;
}); }
chain.use(async (_ctx, next) => { );
order.push(2);
const result = await next();
order.push(3);
return result;
});
await chain.execute({ value: 0 }); const result = await chain.execute({ value: 5 });
expect(order).toEqual([1, 2, 3, 4]); expect(result).toBe(50);
});
}); });
it("should accumulate modifications through the chain", async () => { describe('error handling', () => {
const chain = createMiddlewareChain<{ value: number }>(); it('should propagate errors from middleware', async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (ctx, next) => { chain.use(async () => {
ctx.value += 1; throw new Error('middleware error');
return next(); });
});
chain.use(async (ctx, next) => {
ctx.value *= 2;
return next();
});
chain.use(async (ctx, next) => {
ctx.value += 3;
return next();
});
const result = await chain.execute({ value: 0 }); await expect(chain.execute({ value: 1 })).rejects.toThrow('middleware error');
});
expect(result.value).toBe(5); it('should propagate errors from fallback', async () => {
const chain = createMiddlewareChain<{ value: number }, number>(
async () => {
throw new Error('fallback error');
}
);
await expect(chain.execute({ value: 1 })).rejects.toThrow('fallback error');
});
it('should allow middleware to catch errors from downstream', async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (_ctx, next) => {
try {
return await next();
} catch {
return { value: -1 };
}
});
chain.use(async () => {
throw new Error('downstream error');
});
const result = await chain.execute({ value: 1 });
expect(result.value).toBe(-1);
});
}); });
it("should allow middleware to modify result on the way back", async () => { describe('return type override', () => {
const chain = createMiddlewareChain<{ base: number }, number>( it('should support different TReturn type than TContext', async () => {
async (ctx) => ctx.base, const chain = createMiddlewareChain<{ name: string }, string>(
); async ctx => `Hello, ${ctx.name}!`
);
chain.use(async (_ctx, next) => { const result = await chain.execute({ name: 'World' });
const result = await next();
return result + 10;
});
chain.use(async (_ctx, next) => {
const result = await next();
return result * 2;
});
const result = await chain.execute({ base: 5 }); expect(result).toBe('Hello, World!');
});
expect(result).toBe(20); it('should allow middleware to transform return type', async () => {
const chain = createMiddlewareChain<{ items: number[] }, number>(
async ctx => ctx.items.reduce((a, b) => a + b, 0)
);
chain.use(async (_ctx, next) => {
const sum = await next();
return sum * 2;
});
const result = await chain.execute({ items: [1, 2, 3] });
expect(result).toBe(12);
});
}); });
it("should allow middleware to short-circuit in the middle", async () => { describe('reusability', () => {
const executed: number[] = []; it('should reset index on each execute call', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ count: number }>();
chain.use(async (_ctx, next) => { chain.use(async (ctx, next) => {
executed.push(1); ctx.count += 1;
return next(); return next();
}); });
chain.use(async () => {
executed.push(2);
return { value: -1 };
});
chain.use(async (_ctx, next) => {
executed.push(3);
return next();
});
const result = await chain.execute({ value: 100 }); const resultA = await chain.execute({ count: 0 });
const resultB = await chain.execute({ count: 0 });
expect(result.value).toBe(-1); expect(resultA.count).toBe(1);
expect(executed).toEqual([1, 2]); expect(resultB.count).toBe(1);
}); });
});
describe("nested next calls", () => { it('should share middlewares across execute calls', async () => {
it("should advance index on each next call, skipping remaining middlewares", async () => { const chain = createMiddlewareChain<{ log: string[] }>();
const chain = createMiddlewareChain<{ counter: number }>();
chain.use(async (_ctx, next) => { chain.use(async (ctx, next) => {
await next(); ctx.log.push('always');
await next(); return next();
return undefined as unknown as { counter: number }; });
});
const result = await chain.execute({ counter: 0 }); await chain.execute({ log: [] });
await chain.execute({ log: [] });
expect(result).toBeUndefined(); expect(chain).toBeDefined();
});
}); });
it("should allow middleware to call next conditionally", async () => { describe('edge cases', () => {
const chain = createMiddlewareChain<{ skip: boolean; value: number }>(); it('should handle empty context object', async () => {
const chain = createMiddlewareChain<Record<string, never>>();
const result = await chain.execute({});
chain.use(async (ctx, next) => { expect(result).toEqual({});
if (ctx.skip) { });
return { skip: ctx.skip, value: -1 };
}
return next();
});
chain.use(async (ctx, next) => {
ctx.value += 10;
return next();
});
const resultA = await chain.execute({ skip: true, value: 0 }); it('should handle middleware that returns a completely different object', async () => {
const resultB = await chain.execute({ skip: false, value: 0 }); const chain = createMiddlewareChain<{ x: number }, { y: string }>(
async () => ({ y: 'default' })
);
expect(resultA.value).toBe(-1); chain.use(async (_ctx, next) => {
expect(resultB.value).toBe(10); return next();
});
const result = await chain.execute({ x: 42 });
expect(result).toEqual({ y: 'default' });
});
it('should handle middleware that mutates context without returning', async () => {
const chain = createMiddlewareChain<{ value: number }>(
async ctx => ctx
);
chain.use(async (ctx, next) => {
ctx.value = 100;
return next();
});
const result = await chain.execute({ value: 0 });
expect(result.value).toBe(100);
});
it('should return undefined when middleware does not call next or return', async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (ctx) => {
ctx.value = 100;
});
const result = await chain.execute({ value: 0 });
expect(result).toBeUndefined();
});
}); });
it("should handle middleware that awaits next multiple times with a fallback", async () => {
const log: string[] = [];
const chain = createMiddlewareChain<{ value: number }, string[]>(
async (_ctx) => log,
);
chain.use(async (_ctx, next) => {
log.push("before");
await next();
log.push("after-first");
await next();
log.push("after-second");
return log;
});
chain.use(async (_ctx, next) => {
log.push("mw2");
return next();
});
const result = await chain.execute({ value: 0 });
expect(result).toEqual(["before", "mw2", "after-first", "after-second"]);
});
it("should return fallback result on second next call when no more middlewares remain", async () => {
const chain = createMiddlewareChain<{ value: number }, number>(
async (ctx) => ctx.value * 10,
);
chain.use(async (_ctx, next) => {
await next();
return await next();
});
chain.use(async (_ctx, next) => {
return next();
});
const result = await chain.execute({ value: 5 });
expect(result).toBe(50);
});
it("should return fallback result on second next call when no more middlewares remain", async () => {
const chain = createMiddlewareChain<{ value: number }, number>(
async (ctx) => ctx.value * 10,
);
chain.use(async (_ctx, next) => {
await next();
return await next();
});
chain.use(async (_ctx, next) => {
return next();
});
const result = await chain.execute({ value: 5 });
expect(result).toBe(50);
});
});
describe("async behavior", () => {
it("should handle async middlewares", async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (ctx, next) => {
await new Promise((resolve) => setTimeout(resolve, 10));
ctx.value += 1;
return next();
});
chain.use(async (ctx, next) => {
await new Promise((resolve) => setTimeout(resolve, 10));
ctx.value += 2;
return next();
});
const result = await chain.execute({ value: 0 });
expect(result.value).toBe(3);
});
it("should handle async fallback", async () => {
const chain = createMiddlewareChain<{ value: number }, number>(
async (ctx) => {
await new Promise((resolve) => setTimeout(resolve, 10));
return ctx.value * 10;
},
);
const result = await chain.execute({ value: 5 });
expect(result).toBe(50);
});
});
describe("error handling", () => {
it("should propagate errors from middleware", async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async () => {
throw new Error("middleware error");
});
await expect(chain.execute({ value: 1 })).rejects.toThrow(
"middleware error",
);
});
it("should propagate errors from fallback", async () => {
const chain = createMiddlewareChain<{ value: number }, number>(
async () => {
throw new Error("fallback error");
},
);
await expect(chain.execute({ value: 1 })).rejects.toThrow(
"fallback error",
);
});
it("should allow middleware to catch errors from downstream", async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (_ctx, next) => {
try {
return await next();
} catch {
return { value: -1 };
}
});
chain.use(async () => {
throw new Error("downstream error");
});
const result = await chain.execute({ value: 1 });
expect(result.value).toBe(-1);
});
});
describe("return type override", () => {
it("should support different TReturn type than TContext", async () => {
const chain = createMiddlewareChain<{ name: string }, string>(
async (ctx) => `Hello, ${ctx.name}!`,
);
const result = await chain.execute({ name: "World" });
expect(result).toBe("Hello, World!");
});
it("should allow middleware to transform return type", async () => {
const chain = createMiddlewareChain<{ items: number[] }, number>(
async (ctx) => ctx.items.reduce((a, b) => a + b, 0),
);
chain.use(async (_ctx, next) => {
const sum = await next();
return sum * 2;
});
const result = await chain.execute({ items: [1, 2, 3] });
expect(result).toBe(12);
});
});
describe("reusability", () => {
it("should reset index on each execute call", async () => {
const chain = createMiddlewareChain<{ count: number }>();
chain.use(async (ctx, next) => {
ctx.count += 1;
return next();
});
const resultA = await chain.execute({ count: 0 });
const resultB = await chain.execute({ count: 0 });
expect(resultA.count).toBe(1);
expect(resultB.count).toBe(1);
});
it("should share middlewares across execute calls", async () => {
const chain = createMiddlewareChain<{ log: string[] }>();
chain.use(async (ctx, next) => {
ctx.log.push("always");
return next();
});
await chain.execute({ log: [] });
await chain.execute({ log: [] });
expect(chain).toBeDefined();
});
});
describe("edge cases", () => {
it("should handle empty context object", async () => {
const chain = createMiddlewareChain<Record<string, never>>();
const result = await chain.execute({});
expect(result).toEqual({});
});
it("should handle middleware that returns a completely different object", async () => {
const chain = createMiddlewareChain<{ x: number }, { y: string }>(
async () => ({ y: "default" }),
);
chain.use(async (_ctx, next) => {
return next();
});
const result = await chain.execute({ x: 42 });
expect(result).toEqual({ y: "default" });
});
it("should handle middleware that mutates context without returning", async () => {
const chain = createMiddlewareChain<{ value: number }>(
async (ctx) => ctx,
);
chain.use(async (ctx, next) => {
ctx.value = 100;
return next();
});
const result = await chain.execute({ value: 0 });
expect(result.value).toBe(100);
});
it("should return undefined when middleware does not call next or return", async () => {
const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (ctx) => {
ctx.value = 100;
return undefined as unknown as { value: number };
});
const result = await chain.execute({ value: 0 });
expect(result).toBeUndefined();
});
});
}); });