@ryan_nookpi/pi-extension-ask-user-question 0.1.1 → 0.2.1

package/README.md

@@ -1,26 +1,90 @@
 # @ryan_nookpi/pi-extension-ask-user-question
 
-This extension lets pi ask the user questions and wait for an answer during a task.
+pi에서 `ask_user_question` 도구를 추가해, 사용자에게 여러 질문을 한 번에 구조화해서 받을 수 있게 해주는 익스텐션입니다.
 
-It is useful when the request is ambiguous, when the user needs to choose between options, or when you need input before continuing.
-
-## Install
+## 설치
 
 ```bash
 pi install npm:@ryan_nookpi/pi-extension-ask-user-question
 ```
 
-## Great for
+## 무엇을 할 수 있나
+
+- `radio`: 하나만 고르는 단일 선택 질문
+- `checkbox`: 여러 개를 고르는 복수 선택 질문
+- `text`: 자유 입력 질문
+- `allowOther: true`: 선택지 외 값을 직접 입력하는 `기타...` 경로 제공
+- 여러 질문을 한 번의 폼으로 묶어 입력 받기
+
+## 언제 쓰면 좋은가
+
+- 요구사항이 모호해서 확인이 필요할 때
+- 여러 선택지 중 하나를 고르게 해야 할 때
+- 선호도, 배포 환경, 옵션 조합 등을 한 번에 수집할 때
+- 일반 텍스트 질문보다 구조화된 응답이 필요할 때
+
+## 파라미터 가이드
+
+### 최상위 필드
 
-- clarifying vague requirements before implementation
-- letting the user choose between options
-- collecting multiple selections from a checklist
-- asking for missing information in the middle of a task
+- `title`: 폼 상단 제목
+- `description`: 폼 설명/안내 문구
+- `questions`: 질문 배열
 
-## Example prompts
+### 질문 필드
+
+- `id`: 질문 식별자
+- `type`: `radio` | `checkbox` | `text`
+- `prompt`: 사용자에게 보여줄 질문 문구
+- `label`: 탭에 표시할 짧은 이름. 생략하면 `Q1`, `Q2`처럼 자동 생성
+- `options`: `radio`/`checkbox`에서 사용할 선택지 목록
+- `allowOther`: `기타...` 직접 입력 허용 여부
+- `required`: 필수 응답 여부
+- `placeholder`: `text` 입력창 플레이스홀더
+- `default`: 기본값. `radio`/`text`는 문자열, `checkbox`는 문자열 배열
+
+### 옵션 필드
+
+- `value`: 실제 반환값
+- `label`: 화면에 보이는 문구
+- `description`: 선택지 아래 보조 설명
+
+## 예시
+
+```json
+{
+  "title": "배포 설정 확인",
+  "description": "진행 전에 몇 가지 선택이 필요합니다.",
+  "questions": [
+    {
+      "id": "env",
+      "type": "radio",
+      "prompt": "어느 환경에 배포할까요?",
+      "options": [
+        { "value": "staging", "label": "스테이징" },
+        { "value": "prod", "label": "프로덕션" }
+      ]
+    },
+    {
+      "id": "targets",
+      "type": "checkbox",
+      "prompt": "이번에 함께 반영할 항목은 무엇인가요?",
+      "options": [
+        { "value": "web", "label": "웹" },
+        { "value": "admin", "label": "어드민" }
+      ]
+    },
+    {
+      "id": "notes",
+      "type": "text",
+      "prompt": "추가로 알아야 할 점이 있나요?",
+      "required": false,
+      "placeholder": "선택 사항"
+    }
+  ]
+}
+```
 
-- "Ask which design option they want."
-- "Show deployment choices and let the user pick one."
-- "Ask the user to select multiple items from a checklist."
+## 반환 형태
 
-After installation, pi can use the `AskUserQuestion` tool for interactive decision-making.
+응답은 각 질문의 `id` 기준으로 정리되어 반환됩니다. 취소 시에는 `cancelled: true`가 내려오고, 완료 시에는 질문별 답변 목록이 포함됩니다.

package/constants.ts

@@ -0,0 +1,10 @@
+export const SYM = {
+	radioOn: "◉",
+	radioOff: "○",
+	checkOn: "☑",
+	checkOff: "☐",
+	pointer: "❯",
+	dot: "·",
+	check: "✓",
+	submit: "✓",
+} as const;

package/controller.test.ts

@@ -0,0 +1,281 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createFormController } from "./controller.ts";
+import { createAnswerState, normalizeQuestions } from "./state.ts";
+import type { EditorAdapter, FormResult, RenderTheme } from "./types.ts";
+
+class FakeEditor implements EditorAdapter {
+	text = "";
+	onSubmit?: (value: string) => void;
+	handledInputs: string[] = [];
+
+	getText(): string {
+		return this.text;
+	}
+
+	setText(text: string): void {
+		this.text = text;
+	}
+
+	handleInput(data: string): void {
+		this.handledInputs.push(data);
+		if (data.length === 1 && data !== "\t") {
+			this.text += data;
+		}
+	}
+
+	render(): string[] {
+		return this.text ? [this.text] : [];
+	}
+}
+
+const theme: RenderTheme = {
+	fg: (_color, text) => text,
+	bg: (_color, text) => `[${text}]`,
+	bold: (text) => text,
+};
+
+function createController(questionInput: Parameters<typeof normalizeQuestions>[0]) {
+	const questions = normalizeQuestions(questionInput);
+	const answerState = createAnswerState(questions);
+	const editor = new FakeEditor();
+	const requestRender = vi.fn();
+	const done = vi.fn<(result: FormResult) => void>();
+	const controller = createFormController({
+		title: "Title",
+		description: "Description",
+		questions,
+		answerState,
+		editor,
+		theme,
+		requestRender,
+		done,
+	});
+	return { controller, questions, answerState, editor, requestRender, done };
+}
+
+describe("ask-user-question/controller", () => {
+	it("renders with caching and supports empty question sets", () => {
+		const empty = createController([]);
+		const firstRender = empty.controller.render(40);
+		const secondRender = empty.controller.render(40);
+		expect(firstRender).toBe(secondRender);
+		empty.controller.invalidate();
+		expect(empty.controller.render(40)).not.toBe(firstRender);
+		empty.controller.handleInput("x");
+		expect(empty.done).not.toHaveBeenCalled();
+	});
+
+	it("handles text questions, submission, cancellation, and editor fallback submit", () => {
+		const first = createController([{ id: "text", type: "text", prompt: "Explain", default: "seed" }]);
+		expect(first.editor.getText()).toBe("seed");
+
+		first.controller.handleInput("!");
+		first.controller.handleInput("\r");
+		expect(first.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: first.questions,
+			answers: [{ id: "text", type: "text", value: "seed!", wasCustom: true }],
+			cancelled: false,
+		});
+		expect(first.requestRender).toHaveBeenCalled();
+
+		const cancelled = createController([{ id: "text", type: "text", prompt: "Explain" }]);
+		cancelled.controller.handleInput("\u001b");
+		expect(cancelled.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: cancelled.questions,
+			answers: [{ id: "text", type: "text", value: "", wasCustom: true }],
+			cancelled: true,
+		});
+
+		const fallback = createController([{ id: "text", type: "text", prompt: "Explain" }]);
+		fallback.editor.onSubmit?.("  from submit  ");
+		expect(fallback.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: fallback.questions,
+			answers: [{ id: "text", type: "text", value: "from submit", wasCustom: true }],
+			cancelled: false,
+		});
+	});
+
+	it("handles radio other-mode editing, tab navigation, and cancellation", () => {
+		const setup = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "text", type: "text", prompt: "Explain" },
+		]);
+		setup.answerState.radioAnswers.set("radio", { value: "saved", label: "saved", wasCustom: true });
+
+		setup.controller.handleInput("\u001b[B");
+		setup.controller.handleInput("\u001b[A");
+		setup.controller.handleInput("\u001b[B");
+		setup.controller.handleInput("\r");
+		expect(setup.controller.getState()).toMatchObject({ otherMode: true, otherQuestionId: "radio" });
+		expect(setup.editor.getText()).toBe("saved");
+		expect(setup.controller.render(80).join("\n")).toContain("직접 입력:");
+
+		setup.controller.handleInput("x");
+		setup.controller.handleInput("\t");
+		expect(setup.answerState.radioAnswers.get("radio")).toEqual({ value: "savedx", label: "savedx", wasCustom: true });
+		expect(setup.controller.getState()).toMatchObject({ currentTab: 1, otherMode: false });
+
+		setup.controller.handleInput("\u001b[Z");
+		expect(setup.controller.getState().currentTab).toBe(0);
+		setup.controller.handleInput("\u001b");
+		expect(setup.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: setup.questions,
+			answers: [
+				{ id: "radio", type: "radio", value: "savedx", wasCustom: true },
+				{ id: "text", type: "text", value: "", wasCustom: true },
+			],
+			cancelled: true,
+		});
+	});
+
+	it("supports radio selection, checkbox toggles, other-mode enter, and successful submit", () => {
+		const setup = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "check", type: "checkbox", prompt: "Pick many", options: [{ value: "b", label: "Beta" }] },
+		]);
+
+		setup.controller.handleInput("\r");
+		expect(setup.controller.getState().currentTab).toBe(1);
+		expect(setup.answerState.radioAnswers.get("radio")).toEqual({ value: "a", label: "Alpha", wasCustom: false });
+
+		setup.controller.handleInput(" ");
+		expect(setup.answerState.checkAnswers.get("check")).toEqual(new Set(["b"]));
+		setup.controller.handleInput(" ");
+		expect(setup.answerState.checkAnswers.get("check")).toEqual(new Set());
+
+		setup.controller.handleInput("\u001b[B");
+		setup.controller.handleInput(" ");
+		expect(setup.controller.getState().otherMode).toBe(true);
+		setup.editor.setText("custom");
+		setup.controller.handleInput("\r");
+		expect(setup.answerState.checkCustom.get("check")).toBe("custom");
+		expect(setup.controller.getState().currentTab).toBe(2);
+
+		setup.controller.handleInput("\r");
+		expect(setup.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: setup.questions,
+			answers: [
+				{ id: "radio", type: "radio", value: "a", wasCustom: false },
+				{ id: "check", type: "checkbox", value: ["custom"], wasCustom: true },
+			],
+			cancelled: false,
+		});
+	});
+
+	it("handles onSubmit custom input, no-option branches, submit-tab navigation, and other-mode escape", () => {
+		const submitOther = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "text", type: "text", prompt: "Explain" },
+		]);
+		submitOther.controller.handleInput("\u001b[B");
+		submitOther.controller.handleInput("\r");
+		submitOther.editor.onSubmit?.("typed");
+		expect(submitOther.answerState.radioAnswers.get("radio")).toEqual({
+			value: "typed",
+			label: "typed",
+			wasCustom: true,
+		});
+		expect(submitOther.controller.getState().currentTab).toBe(1);
+
+		const nonTextSubmit = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+		]);
+		nonTextSubmit.editor.onSubmit?.("ignored");
+		expect(nonTextSubmit.done).not.toHaveBeenCalled();
+
+		const shiftOther = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "text", type: "text", prompt: "Explain" },
+		]);
+		shiftOther.controller.handleInput("\u001b[B");
+		shiftOther.controller.handleInput("\r");
+		shiftOther.editor.setText("back");
+		shiftOther.controller.handleInput("\u001b[Z");
+		expect(shiftOther.answerState.radioAnswers.get("radio")).toEqual({ value: "back", label: "back", wasCustom: true });
+		expect(shiftOther.controller.getState().currentTab).toBe(2);
+
+		const noOptions = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [], allowOther: false },
+			{ id: "check", type: "checkbox", prompt: "Pick many", options: [], allowOther: false },
+		]);
+		noOptions.controller.handleInput("\r");
+		expect(noOptions.done).not.toHaveBeenCalled();
+		noOptions.controller.handleInput("\u001b[C");
+		noOptions.controller.handleInput("\u001b[D");
+		expect(noOptions.controller.getState().currentTab).toBe(0);
+		noOptions.controller.handleInput("\u001b[C");
+		noOptions.controller.handleInput(" ");
+		noOptions.controller.handleInput("\r");
+		expect(noOptions.controller.getState().currentTab).toBe(2);
+
+		const deletedSet = createController([
+			{ id: "check", type: "checkbox", prompt: "Pick many", options: [{ value: "b", label: "Beta" }] },
+		]);
+		deletedSet.answerState.checkAnswers.delete("check");
+		deletedSet.controller.handleInput(" ");
+		expect(deletedSet.answerState.checkAnswers.get("check")).toEqual(new Set(["b"]));
+		deletedSet.controller.handleInput("x");
+		expect(deletedSet.done).not.toHaveBeenCalled();
+
+		const checkboxSingle = createController([{ id: "check", type: "checkbox", prompt: "Pick many", options: [] }]);
+		checkboxSingle.controller.handleInput("\r");
+		expect(checkboxSingle.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: checkboxSingle.questions,
+			answers: [{ id: "check", type: "checkbox", value: [], wasCustom: false }],
+			cancelled: false,
+		});
+
+		const blocked = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "text", type: "text", prompt: "Explain" },
+		]);
+		blocked.controller.handleInput("\u001b[C");
+		blocked.controller.handleInput("\t");
+		expect(blocked.controller.getState().currentTab).toBe(2);
+		blocked.controller.handleInput("\r");
+		expect(blocked.done).not.toHaveBeenCalled();
+		blocked.controller.handleInput("\u001b[D");
+		expect(blocked.controller.getState().currentTab).toBe(1);
+		blocked.controller.handleInput("\t");
+		expect(blocked.controller.getState().currentTab).toBe(2);
+		blocked.controller.handleInput("\t");
+		expect(blocked.controller.getState().currentTab).toBe(0);
+		blocked.controller.handleInput("\u001b");
+		expect(blocked.done).toHaveBeenCalled();
+
+		const submitCancel = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }], default: "a" },
+			{ id: "text", type: "text", prompt: "Explain", default: "done" },
+		]);
+		submitCancel.controller.handleInput("\u001b[C");
+		submitCancel.controller.handleInput("\t");
+		submitCancel.controller.handleInput("\u001b");
+		expect(submitCancel.done).toHaveBeenCalled();
+
+		const submitNav = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }], default: "a" },
+			{ id: "text", type: "text", prompt: "Explain", default: "done" },
+		]);
+		submitNav.controller.handleInput("\u001b[C");
+		submitNav.controller.handleInput("\t");
+		expect(submitNav.controller.getState().currentTab).toBe(2);
+		submitNav.controller.handleInput("\u001b[C");
+		expect(submitNav.controller.getState().currentTab).toBe(0);
+
+		const otherEscape = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+		]);
+		otherEscape.controller.handleInput("\u001b[B");
+		otherEscape.controller.handleInput("\r");
+		otherEscape.controller.handleInput("\u001b");
+		expect(otherEscape.controller.getState()).toMatchObject({ otherMode: false, otherQuestionId: null });
+		expect(otherEscape.editor.getText()).toBe("");
+	});
+});

package/controller.ts

@@ -0,0 +1,280 @@
+import { Key, matchesKey } from "@mariozechner/pi-tui";
+
+import { allRequiredAnswered, buildAnswers, optionCount, saveOtherAnswer, saveTextAnswer } from "./state.ts";
+import type { AnswerState, EditorAdapter, FormResult, NormalizedQuestion, RenderTheme } from "./types.ts";
+import { renderForm } from "./view.ts";
+
+export interface FormController {
+	render(width: number): string[];
+	invalidate(): void;
+	handleInput(data: string): void;
+	getState(): {
+		currentTab: number;
+		cursorIdx: number;
+		otherMode: boolean;
+		otherQuestionId: string | null;
+	};
+}
+
+interface CreateFormControllerInput {
+	title?: string;
+	description?: string;
+	questions: NormalizedQuestion[];
+	answerState: AnswerState;
+	editor: EditorAdapter;
+	theme: RenderTheme;
+	requestRender(): void;
+	done(result: FormResult): void;
+}
+
+export function createFormController(input: CreateFormControllerInput): FormController {
+	const { questions, answerState, editor, theme } = input;
+	const isMulti = questions.length > 1;
+	const totalTabs = questions.length + (isMulti ? 1 : 0);
+
+	let currentTab = 0;
+	let cursorIdx = 0;
+	let otherMode = false;
+	let otherQuestionId: string | null = null;
+	let cachedLines: string[] | undefined;
+
+	function getCurrentQuestion(): NormalizedQuestion | undefined {
+		return questions[currentTab];
+	}
+
+	function refresh(): void {
+		cachedLines = undefined;
+		input.requestRender();
+	}
+
+	function saveCurrentTextQuestion(): void {
+		const question = getCurrentQuestion();
+		if (question?.type !== "text") return;
+		saveTextAnswer(answerState, question.id, editor.getText());
+	}
+
+	function saveOtherModeText(questionId: string): void {
+		saveOtherAnswer(answerState, questions, questionId, editor.getText());
+		otherMode = false;
+		otherQuestionId = null;
+		editor.setText("");
+	}
+
+	function switchTab(nextTab: number): void {
+		saveCurrentTextQuestion();
+		currentTab = ((nextTab % totalTabs) + totalTabs) % totalTabs;
+		cursorIdx = 0;
+		otherMode = false;
+		otherQuestionId = null;
+		const question = getCurrentQuestion();
+		if (question?.type === "text") {
+			editor.setText(answerState.textAnswers.get(question.id) ?? "");
+		}
+		refresh();
+	}
+
+	function finish(cancelled: boolean): void {
+		saveCurrentTextQuestion();
+		input.done({
+			title: input.title,
+			questions,
+			answers: buildAnswers(answerState, questions),
+			cancelled,
+		});
+	}
+
+	function advanceTab(): void {
+		if (!isMulti) {
+			finish(false);
+			return;
+		}
+		switchTab(currentTab < questions.length - 1 ? currentTab + 1 : questions.length);
+	}
+
+	editor.onSubmit = (value) => {
+		const trimmed = value.trim();
+		if (otherMode && otherQuestionId) {
+			saveOtherAnswer(answerState, questions, otherQuestionId, trimmed);
+			otherMode = false;
+			otherQuestionId = null;
+			editor.setText("");
+			advanceTab();
+			return;
+		}
+
+		const question = getCurrentQuestion();
+		if (question?.type === "text") {
+			saveTextAnswer(answerState, question.id, trimmed);
+			editor.setText(trimmed);
+			advanceTab();
+		}
+	};
+
+	if (questions[0]?.type === "text") {
+		editor.setText(answerState.textAnswers.get(questions[0].id) ?? "");
+	}
+
+	return {
+		render(width) {
+			if (cachedLines) return cachedLines;
+			cachedLines = renderForm({
+				title: input.title,
+				description: input.description,
+				questions,
+				answerState,
+				currentTab,
+				cursorIdx,
+				otherMode,
+				width,
+				theme,
+				editorLines: editor.render(Math.min(width, 120) - (otherMode ? 6 : 4)),
+				editorText: editor.getText(),
+			});
+			return cachedLines;
+		},
+		invalidate() {
+			cachedLines = undefined;
+		},
+		handleInput(data) {
+			if (otherMode) {
+				if (matchesKey(data, Key.escape)) {
+					otherMode = false;
+					otherQuestionId = null;
+					editor.setText("");
+					refresh();
+					return;
+				}
+				if (matchesKey(data, Key.enter) && otherQuestionId) {
+					saveOtherModeText(otherQuestionId);
+					advanceTab();
+					return;
+				}
+				if (isMulti && (matchesKey(data, Key.tab) || matchesKey(data, Key.shift("tab"))) && otherQuestionId) {
+					saveOtherModeText(otherQuestionId);
+					switchTab(currentTab + (matchesKey(data, Key.shift("tab")) ? -1 : 1));
+					return;
+				}
+				editor.handleInput(data);
+				refresh();
+				return;
+			}
+
+			const question = getCurrentQuestion();
+			if (question?.type === "text") {
+				if (matchesKey(data, Key.enter)) {
+					saveCurrentTextQuestion();
+					advanceTab();
+					return;
+				}
+				if (isMulti && (matchesKey(data, Key.tab) || matchesKey(data, Key.shift("tab")))) {
+					saveCurrentTextQuestion();
+					switchTab(currentTab + (matchesKey(data, Key.shift("tab")) ? -1 : 1));
+					return;
+				}
+				if (matchesKey(data, Key.escape)) {
+					finish(true);
+					return;
+				}
+				editor.handleInput(data);
+				refresh();
+				return;
+			}
+
+			if (isMulti && currentTab === questions.length) {
+				if (matchesKey(data, Key.enter) && allRequiredAnswered(answerState, questions)) {
+					finish(false);
+					return;
+				}
+				if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
+					switchTab(0);
+					return;
+				}
+				if (matchesKey(data, Key.shift("tab")) || matchesKey(data, Key.left)) {
+					switchTab(currentTab - 1);
+					return;
+				}
+				if (matchesKey(data, Key.escape)) {
+					finish(true);
+					return;
+				}
+				return;
+			}
+
+			if (!question) return;
+
+			if (isMulti) {
+				if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
+					switchTab(currentTab + 1);
+					return;
+				}
+				if (matchesKey(data, Key.shift("tab")) || matchesKey(data, Key.left)) {
+					switchTab(currentTab - 1);
+					return;
+				}
+			}
+
+			const totalOptions = optionCount(question);
+			if (matchesKey(data, Key.up)) {
+				cursorIdx = Math.max(0, cursorIdx - 1);
+				refresh();
+				return;
+			}
+			if (matchesKey(data, Key.down)) {
+				cursorIdx = Math.min(totalOptions - 1, cursorIdx + 1);
+				refresh();
+				return;
+			}
+			if (matchesKey(data, Key.escape)) {
+				finish(true);
+				return;
+			}
+
+			if (question.type === "radio" && matchesKey(data, Key.enter)) {
+				const isOther = question.allowOther && cursorIdx === question.options.length;
+				if (isOther) {
+					otherMode = true;
+					otherQuestionId = question.id;
+					const existing = answerState.radioAnswers.get(question.id);
+					editor.setText(existing?.wasCustom ? existing.label : "");
+					refresh();
+					return;
+				}
+
+				const option = question.options[cursorIdx];
+				if (option) {
+					answerState.radioAnswers.set(question.id, { value: option.value, label: option.label, wasCustom: false });
+					advanceTab();
+				}
+				return;
+			}
+
+			if (question.type === "checkbox" && matchesKey(data, Key.space)) {
+				const isOther = question.allowOther && cursorIdx === question.options.length;
+				if (isOther) {
+					otherMode = true;
+					otherQuestionId = question.id;
+					editor.setText(answerState.checkCustom.get(question.id) ?? "");
+					refresh();
+					return;
+				}
+
+				const option = question.options[cursorIdx];
+				if (option) {
+					const selected = answerState.checkAnswers.get(question.id) ?? new Set<string>();
+					if (selected.has(option.value)) selected.delete(option.value);
+					else selected.add(option.value);
+					answerState.checkAnswers.set(question.id, selected);
+					refresh();
+				}
+				return;
+			}
+
+			if (question.type === "checkbox" && matchesKey(data, Key.enter)) {
+				advanceTab();
+			}
+		},
+		getState() {
+			return { currentTab, cursorIdx, otherMode, otherQuestionId };
+		},
+	};
+}