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

Compare commits

base: hypercross:15122defcc9b10de33299d277341504402261294
Branches Tags
hypercross:master
..
compare: hypercross:d4d428b577b7ef061e3dcb4e4ff87ae02aebafca
Branches Tags
hypercross:master

No commits in common. "15122defcc9b10de33299d277341504402261294" and "d4d428b577b7ef061e3dcb4e4ff87ae02aebafca" have entirely different histories.
15122defcc ... d4d428b577

9 changed files with 109 additions and 250 deletions
Show Stats Expand all files Collapse all files

2
package-lock.json generated
View File

@ -1656,7 +1656,7 @@
},
"node_modules/inline-schema": {
"version": "1.0.0",
"resolved": "git+https://gitea.ayi-games.online/hypercross/inline-schema#16d88d610827b5df7f77d7bc22f66b0a8a802dd7",
"resolved": "git+https://gitea.ayi-games.online/hypercross/inline-schema#cf55295ce79a2dcf3114e2910cc6a28ce872be90",
"license": "ISC",
"dependencies": {
"csv-parse": "^5.5.6"

55
src/samples/boop/index.ts
View File

@ -17,7 +17,6 @@ type PlayerSupply = {
cat: PieceSupply;
};
// TODO refactor this into an Entity
function createPlayerSupply(): PlayerSupply {
return {
kitten: { supply: MAX_PIECES_PER_PLAYER, placed: 0 },
@ -68,45 +67,37 @@ registration.add('setup', async function() {
registration.add('turn <player>', async function(cmd) {
const [turnPlayer] = cmd.params as [PlayerType];
const maxRetries = 50;
let retries = 0;
const playCmd = await this.prompt(
'play <player> <row:number> <col:number> [type:string]',
(command) => {
const [player, row, col, type] = command.params as [PlayerType, number, number, PieceType?];
const pieceType = type === 'cat' ? 'cat' : 'kitten';
while (retries < maxRetries) {
retries++;
const playCmd = await this.prompt('play <player> <row:number> <col:number> [type:string]');
const [player, row, col, type] = playCmd.params as [PlayerType, number, number, PieceType?];
const pieceType = type === 'cat' ? 'cat' : 'kitten';
if (player !== turnPlayer) {
return `Invalid player: ${player}. Expected ${turnPlayer}.`;
}
if (!isValidMove(row, col)) {
return `Invalid position: (${row}, ${col}). Must be between 0 and ${BOARD_SIZE - 1}.`;
}
if (isCellOccupied(this.context, row, col)) {
return `Cell (${row}, ${col}) is already occupied.`;
}
if (player !== turnPlayer) continue;
if (!isValidMove(row, col)) continue;
if (isCellOccupied(this.context, row, col)) continue;
const supply = this.context.value.players[player][pieceType].supply;
if (supply <= 0) {
return `No ${pieceType}s left in ${player}'s supply.`;
}
return null;
const supply = this.context.value.players[player][pieceType].supply;
if (supply <= 0) continue;
placePiece(this.context, row, col, turnPlayer, pieceType);
applyBoops(this.context, row, col, pieceType);
const graduatedLines = checkGraduation(this.context, turnPlayer);
if (graduatedLines.length > 0) {
processGraduation(this.context, turnPlayer, graduatedLines);
}
);
const [player, row, col, type] = playCmd.params as [PlayerType, number, number, PieceType?];
const pieceType = type === 'cat' ? 'cat' : 'kitten';
placePiece(this.context, row, col, turnPlayer, pieceType);
applyBoops(this.context, row, col, pieceType);
const winner = checkWinner(this.context);
if (winner) return { winner };
const graduatedLines = checkGraduation(this.context, turnPlayer);
if (graduatedLines.length > 0) {
processGraduation(this.context, turnPlayer, graduatedLines);
return { winner: null };
}
const winner = checkWinner(this.context);
if (winner) return { winner };
return { winner: null };
throw new Error('Too many invalid attempts');
});
function isValidMove(row: number, col: number): boolean {

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

@ -61,33 +61,28 @@ registration.add('setup', async function() {
registration.add('turn <player> <turn:number>', async function(cmd) {
const [turnPlayer, turnNumber] = cmd.params as [PlayerType, number];
const maxRetries = MAX_TURNS * 2;
let retries = 0;
const playCmd = await this.prompt(
'play <player> <row:number> <col:number>',
(command) => {
const [player, row, col] = command.params as [PlayerType, number, number];
while (retries < maxRetries) {
retries++;
const playCmd = await this.prompt('play <player> <row:number> <col:number>');
const [player, row, col] = playCmd.params as [PlayerType, number, number];
if (player !== turnPlayer) {
return `Invalid player: ${player}. Expected ${turnPlayer}.`;
}
if (!isValidMove(row, col)) {
return `Invalid position: (${row}, ${col}). Must be between 0 and ${BOARD_SIZE - 1}.`;
}
if (isCellOccupied(this.context, row, col)) {
return `Cell (${row}, ${col}) is already occupied.`;
}
return null;
}
);
const [player, row, col] = playCmd.params as [PlayerType, number, number];
if (player !== turnPlayer) continue;
if (!isValidMove(row, col)) continue;
if (isCellOccupied(this.context, row, col)) continue;
placePiece(this.context, row, col, turnPlayer);
placePiece(this.context, row, col, turnPlayer);
const winner = checkWinner(this.context);
if (winner) return { winner };
if (turnNumber >= MAX_TURNS) return { winner: 'draw' as WinnerType };
const winner = checkWinner(this.context);
if (winner) return { winner };
if (turnNumber >= MAX_TURNS) return { winner: 'draw' as WinnerType };
return { winner: null };
return { winner: null };
}
throw new Error('Too many invalid attempts');
});
function isValidMove(row: number, col: number): boolean {

48
src/utils/command/command-registry.ts
View File

@ -45,8 +45,8 @@ export type CommandRunnerContextExport<TContext> = CommandRunnerContext<TContext
registry: CommandRegistry<TContext>;
promptQueue: AsyncQueue<PromptEvent>;
_activePrompt: PromptEvent | null;
_tryCommit: (command: Command) => string | null;
_cancel: (reason?: string) => void;
_resolvePrompt: (command: Command) => void;
_rejectPrompt: (error: Error) => void;
_pendingInput: string | null;
};
@ -66,41 +66,25 @@ export function createCommandRunnerContext<TContext>(
let activePrompt: PromptEvent | null = null;
const tryCommit = (command: Command) => {
const resolvePrompt = (command: Command) => {
if (activePrompt) {
const result = activePrompt.tryCommit(command);
if (result === null) {
activePrompt = null;
}
return result;
}
return 'No active prompt';
};
const cancel = (reason?: string) => {
if (activePrompt) {
activePrompt.cancel(reason);
activePrompt.resolve(command);
activePrompt = null;
}
};
const prompt = (
schema: CommandSchema | string,
validator?: (command: Command) => string | null
): Promise<Command> => {
const rejectPrompt = (error: Error) => {
if (activePrompt) {
activePrompt.reject(error);
activePrompt = null;
}
};
const prompt = (schema: Parameters<CommandRunnerContext<TContext>['prompt']>[0]): Promise<Command> => {
const resolvedSchema = typeof schema === 'string' ? parseCommandSchema(schema) : schema;
return new Promise((resolve, reject) => {
const tryCommit = (command: Command) => {
const error = validator?.(command);
if (error) return error;
resolve(command);
return null;
};
const cancel = (reason?: string) => {
reject(new Error(reason ?? 'Cancelled'));
};
activePrompt = { schema: resolvedSchema, tryCommit, cancel };
const event: PromptEvent = { schema: resolvedSchema, tryCommit, cancel };
activePrompt = { schema: resolvedSchema, resolve, reject };
const event: PromptEvent = { schema: resolvedSchema, resolve, reject };
for (const listener of listeners) {
listener(event);
}
@ -116,8 +100,8 @@ export function createCommandRunnerContext<TContext>(
on,
off,
_activePrompt: null,
_tryCommit: tryCommit,
_cancel: cancel,
_resolvePrompt: resolvePrompt,
_rejectPrompt: rejectPrompt,
_pendingInput: null,
promptQueue: null!
};

12
src/utils/command/command-runner.ts
View File

@ -2,14 +2,8 @@ import type { Command, CommandSchema } from './types';
export type PromptEvent = {
schema: CommandSchema;
/**
* 尝试提交命令
* @returns null - 验证成功，Promise 已 resolve
* @returns string - 验证失败，返回错误消息，Promise 未 resolve
*/
tryCommit: (command: Command) => string | null;
/** 取消 prompt，Promise 被 reject */
cancel: (reason?: string) => void;
resolve: (command: Command) => void;
reject: (error: Error) => void;
};
export type CommandRunnerEvents = {
@ -28,7 +22,7 @@ export type CommandRunnerContext<TContext> = {
context: TContext;
run: <T=unknown>(input: string) => Promise<CommandResult<T>>;
runParsed: (command: Command) => Promise<{ success: true; result: unknown } | { success: false; error: string }>;
prompt: (schema: CommandSchema | string, validator?: (command: Command) => string | null) => Promise<Command>;
prompt: (schema: CommandSchema | string) => Promise<Command>;
on: <T extends keyof CommandRunnerEvents>(event: T, listener: (e: CommandRunnerEvents[T]) => void) => void;
off: <T extends keyof CommandRunnerEvents>(event: T, listener: (e: CommandRunnerEvents[T]) => void) => void;
};

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

@ -64,8 +64,7 @@ describe('createGameContext', () => {
expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe('prompt');
const error = promptEvent.tryCommit({ name: 'prompt', params: ['yes'], options: {}, flags: {} });
expect(error).toBeNull();
promptEvent.resolve({ name: 'prompt', params: ['yes'], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);

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

@ -464,7 +464,7 @@ describe('Boop - game flow', () => {
expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe('play');
promptEvent.cancel('test end');
promptEvent.reject(new Error('test end'));
const result = await runPromise;
expect(result.success).toBe(false);
@ -480,8 +480,7 @@ describe('Boop - game flow', () => {
expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe('play');
const error = promptEvent.tryCommit({ name: 'play', params: ['white', 2, 2], options: {}, flags: {} });
expect(error).toBeNull();
promptEvent.resolve({ name: 'play', params: ['white', 2, 2], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -498,13 +497,12 @@ describe('Boop - game flow', () => {
const runPromise = ctx.commands.run<{winner: WinnerType}>('turn white');
const promptEvent1 = await promptPromise;
// 验证器会拒绝错误的玩家
const error1 = promptEvent1.tryCommit({ name: 'play', params: ['black', 2, 2], options: {}, flags: {} });
expect(error1).toContain('Invalid player');
promptEvent1.resolve({ name: 'play', params: ['black', 2, 2], options: {}, flags: {} });
// 验证失败后，再次尝试有效输入
const error2 = promptEvent1.tryCommit({ name: 'play', params: ['white', 2, 2], options: {}, flags: {} });
expect(error2).toBeNull();
const promptEvent2 = await waitForPrompt(ctx);
expect(promptEvent2).not.toBeNull();
promptEvent2.resolve({ name: 'play', params: ['white', 2, 2], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -521,12 +519,12 @@ describe('Boop - game flow', () => {
const runPromise = ctx.commands.run<{winner: WinnerType}>('turn white');
const promptEvent1 = await promptPromise;
const error1 = promptEvent1.tryCommit({ name: 'play', params: ['white', 2, 2], options: {}, flags: {} });
expect(error1).toContain('occupied');
promptEvent1.resolve({ name: 'play', params: ['white', 2, 2], options: {}, flags: {} });
// 验证失败后，再次尝试有效输入
const error2 = promptEvent1.tryCommit({ name: 'play', params: ['white', 0, 0], options: {}, flags: {} });
expect(error2).toBeNull();
const promptEvent2 = await waitForPrompt(ctx);
expect(promptEvent2).not.toBeNull();
promptEvent2.resolve({ name: 'play', params: ['white', 0, 0], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -545,11 +543,12 @@ describe('Boop - game flow', () => {
const runPromise = ctx.commands.run<{winner: WinnerType}>('turn white');
const promptEvent1 = await promptPromise;
const error1 = promptEvent1.tryCommit({ name: 'play', params: ['white', 0, 0], options: {}, flags: {} });
expect(error1).toContain('No kittens');
promptEvent1.resolve({ name: 'play', params: ['white', 0, 0], options: {}, flags: {} });
// 验证失败后，取消
promptEvent1.cancel('test end');
const promptEvent2 = await waitForPrompt(ctx);
expect(promptEvent2).not.toBeNull();
promptEvent2.reject(new Error('test end'));
const result = await runPromise;
expect(result.success).toBe(false);
@ -562,8 +561,7 @@ describe('Boop - game flow', () => {
let promptPromise = waitForPrompt(ctx);
let runPromise = ctx.commands.run<{winner: WinnerType}>('turn white');
let prompt = await promptPromise;
const error1 = prompt.tryCommit({ name: 'play', params: ['white', 3, 3], options: {}, flags: {} });
expect(error1).toBeNull();
prompt.resolve({ name: 'play', params: ['white', 3, 3], options: {}, flags: {} });
let result = await runPromise;
expect(result.success).toBe(true);
expect(getParts(state).length).toBe(1);
@ -571,8 +569,7 @@ describe('Boop - game flow', () => {
promptPromise = waitForPrompt(ctx);
runPromise = ctx.commands.run<{winner: WinnerType}>('turn black');
prompt = await promptPromise;
const error2 = prompt.tryCommit({ name: 'play', params: ['black', 2, 2], options: {}, flags: {} });
expect(error2).toBeNull();
prompt.resolve({ name: 'play', params: ['black', 2, 2], options: {}, flags: {} });
result = await runPromise;
expect(result.success).toBe(true);
expect(getParts(state).length).toBe(2);
@ -613,8 +610,7 @@ describe('Boop - game flow', () => {
const runPromise = ctx.commands.run<{winner: WinnerType}>('turn white');
const promptEvent = await promptPromise;
const error = promptEvent.tryCommit({ name: 'play', params: ['white', 2, 2, 'cat'], options: {}, flags: {} });
expect(error).toBeNull();
promptEvent.resolve({ name: 'play', params: ['white', 2, 2, 'cat'], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -636,11 +632,12 @@ describe('Boop - game flow', () => {
const runPromise = ctx.commands.run<{winner: WinnerType}>('turn white');
const promptEvent1 = await promptPromise;
const error1 = promptEvent1.tryCommit({ name: 'play', params: ['white', 0, 0, 'cat'], options: {}, flags: {} });
expect(error1).toContain('No cats');
promptEvent1.resolve({ name: 'play', params: ['white', 0, 0, 'cat'], options: {}, flags: {} });
// 验证失败后，取消
promptEvent1.cancel('test end');
const promptEvent2 = await waitForPrompt(ctx);
expect(promptEvent2).not.toBeNull();
promptEvent2.reject(new Error('test end'));
const result = await runPromise;
expect(result.success).toBe(false);

44
tests/samples/tic-tac-toe.test.ts
View File

@ -207,7 +207,7 @@ describe('TicTacToe - game flow', () => {
expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe('play');
promptEvent.cancel('test end');
promptEvent.reject(new Error('test end'));
const result = await runPromise;
expect(result.success).toBe(false);
@ -223,8 +223,7 @@ describe('TicTacToe - game flow', () => {
expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe('play');
const error = promptEvent.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
expect(error).toBeNull();
promptEvent.resolve({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -240,13 +239,12 @@ describe('TicTacToe - game flow', () => {
const runPromise = ctx.commands.run<{winner: WinnerType}>('turn X 1');
const promptEvent1 = await promptPromise;
// 验证器会拒绝错误的玩家
const error1 = promptEvent1.tryCommit({ name: 'play', params: ['O', 1, 1], options: {}, flags: {} });
expect(error1).toContain('Invalid player');
promptEvent1.resolve({ name: 'play', params: ['O', 1, 1], options: {}, flags: {} });
// 验证失败后，再次尝试有效输入
const error2 = promptEvent1.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
expect(error2).toBeNull();
const promptEvent2 = await waitForPrompt(ctx);
expect(promptEvent2).not.toBeNull();
promptEvent2.resolve({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -263,12 +261,12 @@ describe('TicTacToe - game flow', () => {
const runPromise = ctx.commands.run<{winner: WinnerType}>('turn X 1');
const promptEvent1 = await promptPromise;
const error1 = promptEvent1.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
expect(error1).toContain('occupied');
promptEvent1.resolve({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
// 验证失败后，再次尝试有效输入
const error2 = promptEvent1.tryCommit({ name: 'play', params: ['X', 0, 0], options: {}, flags: {} });
expect(error2).toBeNull();
const promptEvent2 = await waitForPrompt(ctx);
expect(promptEvent2).not.toBeNull();
promptEvent2.resolve({ name: 'play', params: ['X', 0, 0], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -281,8 +279,7 @@ describe('TicTacToe - game flow', () => {
let promptPromise = waitForPrompt(ctx);
let runPromise = ctx.commands.run<{winner: WinnerType}>('turn X 1');
let prompt = await promptPromise;
const error1 = prompt.tryCommit({ name: 'play', params: ['X', 0, 0], options: {}, flags: {} });
expect(error1).toBeNull();
prompt.resolve({ name: 'play', params: ['X', 0, 0], options: {}, flags: {} });
let result = await runPromise;
expect(result.success).toBe(true);
if (result.success) expect(result.result.winner).toBeNull();
@ -290,8 +287,7 @@ describe('TicTacToe - game flow', () => {
promptPromise = waitForPrompt(ctx);
runPromise = ctx.commands.run('turn O 2');
prompt = await promptPromise;
const error2 = prompt.tryCommit({ name: 'play', params: ['O', 0, 1], options: {}, flags: {} });
expect(error2).toBeNull();
prompt.resolve({ name: 'play', params: ['O', 0, 1], options: {}, flags: {} });
result = await runPromise;
expect(result.success).toBe(true);
if (result.success) expect(result.result.winner).toBeNull();
@ -299,8 +295,7 @@ describe('TicTacToe - game flow', () => {
promptPromise = waitForPrompt(ctx);
runPromise = ctx.commands.run('turn X 3');
prompt = await promptPromise;
const error3 = prompt.tryCommit({ name: 'play', params: ['X', 1, 0], options: {}, flags: {} });
expect(error3).toBeNull();
prompt.resolve({ name: 'play', params: ['X', 1, 0], options: {}, flags: {} });
result = await runPromise;
expect(result.success).toBe(true);
if (result.success) expect(result.result.winner).toBeNull();
@ -308,8 +303,7 @@ describe('TicTacToe - game flow', () => {
promptPromise = waitForPrompt(ctx);
runPromise = ctx.commands.run('turn O 4');
prompt = await promptPromise;
const error4 = prompt.tryCommit({ name: 'play', params: ['O', 0, 2], options: {}, flags: {} });
expect(error4).toBeNull();
prompt.resolve({ name: 'play', params: ['O', 0, 2], options: {}, flags: {} });
result = await runPromise;
expect(result.success).toBe(true);
if (result.success) expect(result.result.winner).toBeNull();
@ -317,8 +311,7 @@ describe('TicTacToe - game flow', () => {
promptPromise = waitForPrompt(ctx);
runPromise = ctx.commands.run('turn X 5');
prompt = await promptPromise;
const error5 = prompt.tryCommit({ name: 'play', params: ['X', 2, 0], options: {}, flags: {} });
expect(error5).toBeNull();
prompt.resolve({ name: 'play', params: ['X', 2, 0], options: {}, flags: {} });
result = await runPromise;
expect(result.success).toBe(true);
if (result.success) expect(result.result.winner).toBe('X');
@ -348,8 +341,7 @@ describe('TicTacToe - game flow', () => {
const promptPromise = waitForPrompt(ctx);
const runPromise = ctx.commands.run<{winner: WinnerType}>('turn X 9');
const prompt = await promptPromise;
const error = prompt.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
expect(error).toBeNull();
prompt.resolve({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
if (result.success) expect(result.result.winner).toBe('draw');

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

@ -296,8 +296,7 @@ describe('prompt', () => {
expect(promptEvent).not.toBeNull();
const parsed = { name: 'select', params: ['Ace'], options: {}, flags: {} };
const error = promptEvent!.tryCommit(parsed);
expect(error).toBeNull();
promptEvent!.resolve(parsed);
const result = await runPromise;
expect(result.success).toBe(true);
@ -337,7 +336,7 @@ describe('prompt', () => {
await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull();
promptEvent!.cancel('user cancelled');
promptEvent!.reject(new Error('user cancelled'));
const result = await runPromise;
expect(result.success).toBe(true);
@ -374,8 +373,7 @@ describe('prompt', () => {
expect(promptEvent).not.toBeNull();
expect(promptEvent!.schema.name).toBe('pick');
const error = promptEvent!.tryCommit({ name: 'pick', params: ['sword'], options: {}, flags: {} });
expect(error).toBeNull();
promptEvent!.resolve({ name: 'pick', params: ['sword'], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -412,15 +410,13 @@ describe('prompt', () => {
expect(promptEvents.length).toBe(1);
expect(promptEvents[0].schema.name).toBe('first');
const error1 = promptEvents[0].tryCommit({ name: 'first', params: ['one'], options: {}, flags: {} });
expect(error1).toBeNull();
promptEvents[0].resolve({ name: 'first', params: ['one'], options: {}, flags: {} });
await new Promise((r) => setTimeout(r, 0));
expect(promptEvents.length).toBe(2);
expect(promptEvents[1].schema.name).toBe('second');
const error2 = promptEvents[1].tryCommit({ name: 'second', params: ['two'], options: {}, flags: {} });
expect(error2).toBeNull();
promptEvents[1].resolve({ name: 'second', params: ['two'], options: {}, flags: {} });
const result = await runPromise;
expect(result.success).toBe(true);
@ -428,93 +424,4 @@ describe('prompt', () => {
expect(result.result).toEqual(['one', 'two']);
}
});
it('should validate input with validator function', async () => {
const registry = createCommandRegistry<TestContext>();
const chooseRunner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema('choose'),
run: async function () {
const result = await this.prompt(
'select <card>',
(cmd) => {
const card = cmd.params[0] as string;
if (!['Ace', 'King', 'Queen'].includes(card)) {
return `Invalid card: ${card}. Must be Ace, King, or Queen.`;
}
return null;
}
);
return result.params[0] as string;
},
};
registerCommand(registry, chooseRunner);
const ctx = { counter: 0, log: [] };
let promptEvent: PromptEvent | null = null;
const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on('prompt', (e) => {
promptEvent = e;
});
const runPromise = runnerCtx.run('choose');
await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull();
// Try invalid input
const invalidError = promptEvent!.tryCommit({ name: 'select', params: ['Jack'], options: {}, flags: {} });
expect(invalidError).toContain('Invalid card: Jack');
// Try valid input
const validError = promptEvent!.tryCommit({ name: 'select', params: ['Ace'], options: {}, flags: {} });
expect(validError).toBeNull();
const result = await runPromise;
expect(result.success).toBe(true);
if (result.success) {
expect(result.result).toBe('Ace');
}
});
it('should allow cancel with custom reason', async () => {
const registry = createCommandRegistry<TestContext>();
const chooseRunner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema('choose'),
run: async function () {
try {
await this.prompt('select <card>');
return 'unexpected success';
} catch (e) {
return (e as Error).message;
}
},
};
registerCommand(registry, chooseRunner);
const ctx = { counter: 0, log: [] };
let promptEvent: PromptEvent | null = null;
const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on('prompt', (e) => {
promptEvent = e;
});
const runPromise = runnerCtx.run('choose');
await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull();
promptEvent!.cancel('custom cancellation reason');
const result = await runPromise;
expect(result.success).toBe(true);
if (result.success) {
expect(result.result).toBe('custom cancellation reason');
}
});
});