@archytechtor/ui 0.0.0-stage → 0.1.0

package/dist/components/questionnaire/questionnaire-primitive.js

@@ -0,0 +1,1563 @@
+"use client";
+import { mergeProps } from "@base-ui/react/merge-props";
+import { createContext, createElement, use, useCallback, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { useRender } from "@base-ui/react/use-render";
+// src/components/questionnaire/questionnaire-primitive.ts
+/** Типы полей, у которых стрелки вверх/вниз переводят фокус, пока поле пустое */
+const TEXT_INPUT_TYPES = [
+	"email",
+	"password",
+	"search",
+	"tel",
+	"text",
+	"url"
+];
+/** Типы input, которые не считаются полями ввода текста */
+const NON_TEXT_INPUT_TYPES = [
+	"button",
+	"checkbox",
+	"radio",
+	"reset",
+	"submit"
+];
+const RootContext = createContext(null);
+const ItemContext = createContext(null);
+const ChoiceContext = createContext(null);
+/**
+* Контекст опроса или ошибка, если часть вне Questionnaire
+* @param part - имя части для текста ошибки
+* @returns контекст опроса
+*/
+function useRootContext(part) {
+	const context = use(RootContext);
+	if (!context) throw new Error(`${part} должен находиться внутри Questionnaire`);
+	return context;
+}
+/**
+* Контекст вопроса или ошибка, если часть вне QuestionnaireItem
+* @param part - имя части для текста ошибки
+* @returns контекст вопроса
+*/
+function useItemContext(part) {
+	const context = use(ItemContext);
+	if (!context) throw new Error(`${part} должен находиться внутри QuestionnaireItem`);
+	return context;
+}
+/**
+* Контекст варианта или ошибка, если часть вне QuestionnaireChoice
+* @param part - имя части для текста ошибки
+* @returns контекст варианта
+*/
+function useChoiceContext(part) {
+	const context = use(ChoiceContext);
+	if (!context) throw new Error(`${part} должен находиться внутри QuestionnaireChoice`);
+	return context;
+}
+/**
+* Собрать список через пробел без пустых частей
+* @param tokens - части списка
+* @returns строка или undefined, если частей нет
+*/
+function joinTokens(tokens) {
+	const result = [];
+	for (const token of tokens) if (token) result.push(token);
+	return result.join(" ") || void 0;
+}
+/**
+* Есть ли в значении непустой текст
+* @param value - значение поля или список значений
+* @returns true, если есть хотя бы один непустой текст
+*/
+function hasText(value) {
+	if (Array.isArray(value)) return value.some((part) => String(part).trim().length > 0);
+	return value !== null && value !== void 0 && String(value).trim().length > 0;
+}
+/**
+* Клавиши подсказок по режиму
+* @param mode - буквы или цифры
+* @returns A–Z, 1–9 или пустой список
+*/
+function getShortcutKeys(mode) {
+	if (mode === "letters") return Array.from({ length: 26 }, (_, index) => String.fromCharCode(65 + index));
+	if (mode === "numbers") return Array.from({ length: 9 }, (_, index) => String(index + 1));
+	return [];
+}
+/**
+* Клавиша подсказки по нажатой клавише
+* @param key - нажатая клавиша
+* @param mode - буквы или цифры
+* @returns клавиша подсказки или null
+*/
+function getShortcutByKey(key, mode) {
+	const shortcut = mode === "letters" ? key.toUpperCase() : key;
+	if (getShortcutKeys(mode).includes(shortcut)) return shortcut;
+	return null;
+}
+/**
+* Значение aria-keyshortcuts ответа
+* @param shortcut - клавиша варианта
+* @param withEnter - Enter переводит к следующему вопросу
+* @returns список клавиш или undefined
+*/
+function getAnswerKeyShortcuts(shortcut, withEnter) {
+	return joinTokens([shortcut, withEnter ? "Enter" : null]);
+}
+/**
+* Дан ли ответ этим элементом
+* @param control - вариант или поле
+* @returns true, если вариант выбран или в поле есть текст
+*/
+function isAnswered(control) {
+	if (control.type === "choice") return control.element.checked;
+	return control.element.hasAttribute("name") && hasText(control.element.value);
+}
+/**
+* Пустое текстовое поле: из него стрелки переводят фокус к вариантам
+* @param control - вариант или поле
+* @returns true для пустого текстового поля
+*/
+function isEmptyTextInput(control) {
+	return control?.type === "input" && TEXT_INPUT_TYPES.includes(control.element.type) && !hasText(control.element.value);
+}
+/**
+* Элемент ввода текста: в нём стрелки и буквы работают как обычно
+* @param element - элемент
+* @returns true для полей ввода текста
+*/
+function isTextEntry(element) {
+	if (element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) return true;
+	if (element instanceof HTMLInputElement) return !NON_TEXT_INPUT_TYPES.includes(element.type);
+	return element instanceof HTMLElement && element.isContentEditable;
+}
+/**
+* Радиокнопка ли элемент
+* @param element - элемент
+* @returns true для input type=radio
+*/
+function isRadio(element) {
+	return element instanceof HTMLInputElement && element.type === "radio";
+}
+/**
+* Сравнить элементы по порядку в документе
+* @param first - первый элемент
+* @param second - второй элемент
+* @returns -1, если первый раньше, 1 — если позже, 0 — если тот же
+*/
+function compareByDocumentPosition(first, second) {
+	if (first.element === second.element) return 0;
+	const position = first.element.compareDocumentPosition(second.element);
+	if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+	if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+	return 0;
+}
+/**
+* Статус вопроса
+* @param skipped - вопрос пропущен
+* @param answered - есть ответ
+* @returns статус
+*/
+function getItemStatus(skipped, answered) {
+	if (skipped) return "skipped";
+	if (answered) return "answered";
+	return "unanswered";
+}
+/**
+* Разобрать Root items
+* @param items - описания вопросов
+* @returns коллекция или null, если items не переданы
+*/
+function createItemCollection(items) {
+	if (items === void 0) return null;
+	const enabledItems = [];
+	const itemByName = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		if (!item.disabled) enabledItems.push(item);
+		itemByName.set(item.name, item);
+	}
+	return {
+		enabledItems,
+		itemByName,
+		items
+	};
+}
+/**
+* Начальный вопрос: defaultItem, если он включён, иначе первый включённый
+* @param collection - описания вопросов
+* @param defaultItem - желаемый вопрос
+* @returns имя вопроса или null
+*/
+function resolveItemName(collection, defaultItem) {
+	if (!collection) return defaultItem ?? null;
+	const item = defaultItem ? collection.itemByName.get(defaultItem) : void 0;
+	if (item && !item.disabled) return item.name;
+	return collection.enabledItems[0]?.name ?? null;
+}
+/**
+* Клавиши вариантов по значениям из Root items: отключённые варианты пропускаются
+* @param definition - описание вопроса
+* @param mode - буквы или цифры
+* @returns клавиша по значению варианта
+*/
+function getChoiceShortcuts(definition, mode) {
+	const result = /* @__PURE__ */ new Map();
+	if (!definition || !mode) return result;
+	const keys = getShortcutKeys(mode);
+	let index = 0;
+	for (const choice of definition.choices ?? []) {
+		if (choice.disabled) continue;
+		const key = keys[index];
+		if (!key) break;
+		result.set(choice.value, key);
+		index += 1;
+	}
+	return result;
+}
+/**
+* Ошибки в самих Root items: повторы имён и значений, неверный defaultItem
+* @param collection - описания вопросов
+* @param defaultItem - начальный вопрос
+* @returns тексты предупреждений
+*/
+function getDefinitionWarnings(collection, defaultItem) {
+	const result = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const item of collection.items) {
+		if (names.has(item.name)) result.push(`вопрос «${item.name}» описан несколько раз`);
+		names.add(item.name);
+		const values = /* @__PURE__ */ new Set();
+		for (const choice of item.choices ?? []) {
+			if (values.has(choice.value)) result.push(`вариант «${choice.value}» описан несколько раз в вопросе «${item.name}»`);
+			values.add(choice.value);
+		}
+	}
+	if (defaultItem) {
+		const item = collection.itemByName.get(defaultItem);
+		if (!item || item.disabled) result.push(`defaultItem «${defaultItem}» — не включённый вопрос, открыт первый включённый`);
+	}
+	return result;
+}
+/**
+* Расхождения Root items с отрисованными вопросами и вариантами
+* @param collection - описания вопросов
+* @param registeredItems - отрисованные вопросы
+* @param shortcuts - подсказки клавиш
+* @returns тексты предупреждений
+*/
+function getRenderWarnings(collection, registeredItems, shortcuts) {
+	const result = [];
+	const registeredByName = /* @__PURE__ */ new Map();
+	for (const item of registeredItems) registeredByName.set(item.name, item);
+	for (const definition of collection.items) {
+		const item = registeredByName.get(definition.name);
+		if (!item) {
+			if (!definition.disabled) result.push(`вопрос «${definition.name}» описан, но не отрисован`);
+			continue;
+		}
+		if (item.disabled !== Boolean(definition.disabled)) result.push(`у вопроса «${definition.name}» разный disabled в items и QuestionnaireItem`);
+		if (item.required !== Boolean(definition.required)) result.push(`у вопроса «${definition.name}» разный required в items и QuestionnaireItem`);
+		const choices = definition.choices ?? [];
+		const definedValues = /* @__PURE__ */ new Set();
+		const renderedByValue = /* @__PURE__ */ new Map();
+		for (const choice of choices) definedValues.add(choice.value);
+		for (const choice of item.choices) renderedByValue.set(choice.value, choice);
+		for (const choice of choices) {
+			const rendered = renderedByValue.get(choice.value);
+			if (!rendered) {
+				result.push(`вариант «${choice.value}» вопроса «${definition.name}» описан, но не отрисован`);
+				continue;
+			}
+			if (rendered.disabled !== Boolean(choice.disabled)) result.push(`у варианта «${choice.value}» вопроса «${definition.name}» разный disabled в items и QuestionnaireChoice`);
+		}
+		if (!shortcuts) continue;
+		const enabledDefined = [];
+		const enabledRendered = [];
+		for (const choice of item.choices) {
+			if (!definedValues.has(choice.value)) result.push(`вариант «${choice.value}» вопроса «${definition.name}» не описан в items и останется без клавиши`);
+			if (!choice.disabled) enabledRendered.push(choice.value);
+		}
+		for (const choice of choices) if (!choice.disabled) enabledDefined.push(choice.value);
+		const sameValues = enabledDefined.length > 0 && enabledDefined.length === enabledRendered.length && enabledDefined.every((value) => enabledRendered.includes(value));
+		const otherOrder = enabledDefined.some((value, index) => value !== enabledRendered[index]);
+		if (sameValues && otherOrder) result.push(`порядок вариантов вопроса «${definition.name}» в items и в разметке различается`);
+	}
+	for (const item of registeredItems) if (!item.disabled && !collection.itemByName.has(item.name)) result.push(`вопрос «${item.name}» отрисован, но не описан в items и не участвует в опросе`);
+	return result;
+}
+/**
+* Логика варианта ответа: регистрация в вопросе, выбор, клавиша
+* @param parameters - параметры варианта
+* @returns пропсы input и состояние варианта
+*/
+function useChoice({ checked, defaultChecked, disabled, onChange, value }) {
+	const item = useItemContext("QuestionnaireChoice");
+	const id = useId();
+	const [element, setElement] = useState(null);
+	const initialCheckedRef = useRef(defaultChecked);
+	const isControlled = checked !== void 0;
+	const isDisabled = item.disabled || disabled;
+	const isSelected = item.selectedAnswerIds.includes(id);
+	const isSkipped = item.status === "skipped";
+	let isChecked = isSelected;
+	if (isControlled) isChecked = isSkipped ? false : checked;
+	const type = item.multiple ? "checkbox" : "radio";
+	const shortcut = item.shortcutByChoiceValue?.get(value) ?? item.shortcutByAnswerId.get(id) ?? null;
+	const { registerAnswerControl, registerAnswerSelection, resetVersion, setAnswerDefault, syncControlledAnswerSelection } = item;
+	useLayoutEffect(() => registerAnswerSelection(id, initialCheckedRef.current), [id, registerAnswerSelection]);
+	useLayoutEffect(() => setAnswerDefault(id, defaultChecked), [
+		id,
+		defaultChecked,
+		setAnswerDefault
+	]);
+	useLayoutEffect(() => {
+		if (!element) return;
+		return registerAnswerControl({
+			type: "choice",
+			id,
+			element,
+			disabled: isDisabled,
+			ownDisabled: disabled,
+			value
+		});
+	}, [
+		id,
+		disabled,
+		isDisabled,
+		element,
+		registerAnswerControl,
+		value
+	]);
+	useLayoutEffect(() => {
+		if (isControlled) syncControlledAnswerSelection(id, checked);
+	}, [
+		id,
+		isControlled,
+		checked,
+		resetVersion,
+		syncControlledAnswerSelection
+	]);
+	useLayoutEffect(() => {
+		if (!element) return;
+		element.defaultChecked = isControlled ? checked : defaultChecked;
+		if (resetVersion > 0) element.checked = isChecked;
+	}, [
+		isChecked,
+		isControlled,
+		checked,
+		defaultChecked,
+		element,
+		resetVersion
+	]);
+	/**
+	* Вариант выбран или снят пользователем
+	* @param event - событие input
+	*/
+	const handleChange = (event) => {
+		onChange?.(event);
+		if (event.defaultPrevented) return;
+		if (!isControlled) {
+			item.setAnswerSelectionFromInteraction(id, event.target.checked);
+			return;
+		}
+		if (isSkipped && checked === event.target.checked) item.setAnswerSelectionFromInteraction(id, checked);
+	};
+	const name = isSkipped ? void 0 : item.name;
+	const invalid = item.invalid || void 0;
+	const keyShortcuts = getAnswerKeyShortcuts(shortcut, !isDisabled && isChecked);
+	const required = item.required && !item.multiple && !item.hasInputAnswer;
+	return {
+		inputProps: {
+			"ref": setElement,
+			"aria-invalid": invalid,
+			"aria-keyshortcuts": keyShortcuts,
+			"checked": isChecked,
+			"disabled": isDisabled,
+			"id": id,
+			"name": name,
+			"onChange": handleChange,
+			"required": required,
+			"type": type,
+			"value": value
+		},
+		state: {
+			checked: isChecked,
+			disabled: isDisabled,
+			invalid: item.invalid,
+			shortcut,
+			type
+		}
+	};
+}
+/**
+* Логика поля свободного ответа: регистрация в вопросе и учёт ответа
+* @param parameters - параметры поля
+* @returns ref, пропсы input и состояние поля
+*/
+function useInput({ defaultValue, disabled, onChange, type, value }) {
+	const item = useItemContext("QuestionnaireInput");
+	const id = useId();
+	const inputRef = useRef(null);
+	const initialFilledRef = useRef(hasText(defaultValue));
+	const isControlled = value !== void 0;
+	const isDefaultFilled = hasText(defaultValue);
+	const isValueFilled = hasText(value);
+	const [filled, setFilled] = useState(isDefaultFilled);
+	const isDisabled = item.disabled || disabled;
+	const isFilled = isControlled ? isValueFilled : filled;
+	const isSelected = item.selectedAnswerIds.includes(id);
+	const { registerAnswerControl, registerAnswerSelection, resetVersion, setAnswerDefault, syncControlledAnswerSelection } = item;
+	useLayoutEffect(() => registerAnswerSelection(id, initialFilledRef.current), [id, registerAnswerSelection]);
+	useLayoutEffect(() => setAnswerDefault(id, isDefaultFilled), [
+		isDefaultFilled,
+		id,
+		setAnswerDefault
+	]);
+	useLayoutEffect(() => {
+		const element = inputRef.current;
+		if (!element) return;
+		return registerAnswerControl({
+			type: "input",
+			id,
+			element,
+			disabled: isDisabled
+		});
+	}, [
+		isDisabled,
+		id,
+		registerAnswerControl
+	]);
+	useLayoutEffect(() => {
+		if (isControlled) {
+			syncControlledAnswerSelection(id, isValueFilled);
+			return;
+		}
+		if (resetVersion > 0) setFilled(isDefaultFilled);
+	}, [
+		isControlled,
+		isValueFilled,
+		value,
+		isDefaultFilled,
+		id,
+		resetVersion,
+		syncControlledAnswerSelection
+	]);
+	useLayoutEffect(() => {
+		const element = inputRef.current;
+		if (element && isControlled) element.defaultValue = String(value);
+	}, [isControlled, value]);
+	/**
+	* Изменился текст поля
+	* @param event - событие input
+	*/
+	const handleChange = (event) => {
+		onChange?.(event);
+		if (event.defaultPrevented) return;
+		const nextFilled = event.target.value.trim().length > 0;
+		if (!isControlled) {
+			setFilled(nextFilled);
+			item.setAnswerSelectionFromInteraction(id, nextFilled);
+		}
+	};
+	return {
+		inputRef,
+		inputProps: {
+			"aria-invalid": item.invalid || void 0,
+			"aria-keyshortcuts": getAnswerKeyShortcuts(null, !isDisabled && isFilled && isSelected),
+			"defaultValue": isControlled ? void 0 : defaultValue,
+			"disabled": isDisabled,
+			"form": isSelected ? void 0 : "",
+			"id": id,
+			"name": isSelected ? item.name : void 0,
+			"onChange": handleChange,
+			"type": type,
+			"value": isControlled ? value : void 0
+		},
+		state: {
+			disabled: isDisabled,
+			filled: isFilled,
+			invalid: item.invalid
+		}
+	};
+}
+/**
+* Ключ отрисованных вариантов: значения и отключённость по порядку
+* @param controls - элементы ответа по порядку в разметке
+* @returns JSON-список вариантов
+*/
+function getChoicesKey(controls) {
+	const choices = [];
+	for (const control of controls) if (control.type === "choice") choices.push({
+		disabled: control.ownDisabled,
+		value: control.value
+	});
+	return JSON.stringify(choices);
+}
+/**
+* Логика вопроса: ответы, статус, проверка, навигация стрелками и клавишами
+* @param parameters - параметры вопроса
+* @returns контекст, пропсы fieldset и состояние вопроса
+*/
+function useItem({ ariaDescribedBy, ariaKeyShortcuts, disabled, invalid, multiple, name, onStatusChange, required }) {
+	const { activeItemName, domVersion, first, itemDefinitionByName, last, nativeValidation, registerItem, shortcuts } = useRootContext("QuestionnaireItem");
+	const [itemElement, setItemElement] = useState(null);
+	const [answerControls, setAnswerControls] = useState([]);
+	const [attempted, setAttempted] = useState(false);
+	const [selectedAnswerIds, setSelectedAnswerIds] = useState([]);
+	const [skipped, setSkipped] = useState(false);
+	const [resetVersion, setResetVersion] = useState(0);
+	const [descriptionIds, setDescriptionIds] = useState([]);
+	const [errorIds, setErrorIds] = useState([]);
+	const defaultAnswerIdsRef = useRef([]);
+	const multipleRef = useRef(multiple);
+	const previousMultipleRef = useRef(multiple);
+	const itemApiRef = useRef(null);
+	multipleRef.current = multiple;
+	const active = !disabled && activeItemName === name;
+	const sortedControls = useMemo(() => [...answerControls].sort(compareByDocumentPosition), [answerControls, domVersion]);
+	const enabledControls = useMemo(() => sortedControls.filter((control) => !control.disabled), [sortedControls]);
+	const status = getItemStatus(skipped, enabledControls.some((control) => selectedAnswerIds.includes(control.id)));
+	const skippedOptional = status === "skipped" && !required;
+	const valid = disabled || skippedOptional || !invalid && status === "answered";
+	const showInvalid = !disabled && !skippedOptional && (invalid || attempted && !valid);
+	const hasInputAnswer = enabledControls.some((control) => control.type === "input");
+	const statusRef = useRef(status);
+	const definition = itemDefinitionByName?.get(name);
+	const shortcutByChoiceValue = useMemo(() => {
+		if (!itemDefinitionByName) return null;
+		return getChoiceShortcuts(definition, shortcuts);
+	}, [
+		definition,
+		itemDefinitionByName,
+		shortcuts
+	]);
+	const shortcutByAnswerId = useMemo(() => {
+		const result = /* @__PURE__ */ new Map();
+		if (shortcutByChoiceValue) return result;
+		const keys = getShortcutKeys(shortcuts);
+		for (const control of enabledControls) {
+			const key = keys[result.size];
+			if (!key) break;
+			if (control.type === "choice") result.set(control.id, key);
+		}
+		return result;
+	}, [
+		enabledControls,
+		shortcutByChoiceValue,
+		shortcuts
+	]);
+	const registerAnswerControl = useCallback((control) => {
+		setAnswerControls((previous) => {
+			const result = [];
+			for (const current of previous) if (current.element !== control.element && current.id !== control.id) result.push(current);
+			result.push(control);
+			return result;
+		});
+		return () => {
+			setAnswerControls((previous) => previous.filter((current) => current !== control));
+		};
+	}, []);
+	useLayoutEffect(() => {
+		if (statusRef.current !== status) {
+			statusRef.current = status;
+			onStatusChange?.(status);
+		}
+	}, [onStatusChange, status]);
+	const updateSelection = useCallback((id, selected) => {
+		setSelectedAnswerIds((previous) => {
+			if (!selected) return previous.filter((current) => current !== id);
+			if (!multiple) return [id];
+			if (previous.includes(id)) return previous;
+			return [...previous, id];
+		});
+	}, [multiple]);
+	const setAnswerSelectionFromInteraction = useCallback((id, selected) => {
+		setSkipped(false);
+		updateSelection(id, selected);
+	}, [updateSelection]);
+	const syncControlledAnswerSelection = useCallback((id, selected) => {
+		if (selected) setSkipped(false);
+		updateSelection(id, selected);
+	}, [updateSelection]);
+	const registerAnswerSelection = useCallback((id, selected) => {
+		if (selected) {
+			defaultAnswerIdsRef.current = [...defaultAnswerIdsRef.current.filter((current) => current !== id), id];
+			setSelectedAnswerIds((previous) => {
+				if (multipleRef.current) {
+					if (previous.includes(id)) return previous;
+					return [...previous, id];
+				}
+				if (previous.length) return previous;
+				return [id];
+			});
+		}
+		return () => {
+			defaultAnswerIdsRef.current = defaultAnswerIdsRef.current.filter((current) => current !== id);
+			setSelectedAnswerIds((previous) => previous.filter((current) => current !== id));
+		};
+	}, []);
+	const setAnswerDefault = useCallback((id, selected) => {
+		const defaults = defaultAnswerIdsRef.current;
+		if (selected) {
+			if (!defaults.includes(id)) defaultAnswerIdsRef.current = [...defaults, id];
+			return;
+		}
+		defaultAnswerIdsRef.current = defaults.filter((current) => current !== id);
+	}, []);
+	const registerDescription = useCallback((id) => {
+		setDescriptionIds((previous) => {
+			if (previous.includes(id)) return previous;
+			return [...previous, id];
+		});
+		return () => {
+			setDescriptionIds((previous) => previous.filter((current) => current !== id));
+		};
+	}, []);
+	const registerError = useCallback((id) => {
+		setErrorIds((previous) => {
+			if (previous.includes(id)) return previous;
+			return [...previous, id];
+		});
+		return () => {
+			setErrorIds((previous) => previous.filter((current) => current !== id));
+		};
+	}, []);
+	const validate = useCallback(() => {
+		setAttempted(true);
+		if (!valid) return false;
+		if (!nativeValidation) return true;
+		const invalidControl = enabledControls.find((control) => isAnswered(control) && control.element.willValidate && !control.element.validity.valid);
+		if (invalidControl) {
+			invalidControl.element.focus();
+			invalidControl.element.reportValidity();
+			return false;
+		}
+		return true;
+	}, [
+		enabledControls,
+		nativeValidation,
+		valid
+	]);
+	const focus = useCallback(() => {
+		itemElement?.focus();
+	}, [itemElement]);
+	const focusInvalid = useCallback(() => {
+		const filledInput = itemElement?.querySelector("input[data-filled][name]:not(:disabled)");
+		const firstField = itemElement?.querySelector("input:not([type=hidden]):not(:disabled), textarea:not(:disabled)");
+		(filledInput ?? firstField ?? itemElement)?.focus();
+	}, [itemElement]);
+	const reset = useCallback(() => {
+		const defaults = defaultAnswerIdsRef.current;
+		const nextSelection = multiple ? [...defaults] : defaults.slice(0, 1);
+		setAttempted(false);
+		setSkipped(false);
+		setSelectedAnswerIds(nextSelection);
+		setResetVersion((previous) => previous + 1);
+	}, [multiple]);
+	const skip = useCallback(() => {
+		if (required) return;
+		setSelectedAnswerIds([]);
+		setSkipped(true);
+	}, [required]);
+	useLayoutEffect(() => {
+		const wasMultiple = previousMultipleRef.current;
+		previousMultipleRef.current = multiple;
+		if (!wasMultiple || multiple) return;
+		setSelectedAnswerIds((previous) => {
+			const firstSelected = enabledControls.find((control) => previous.includes(control.id));
+			if (firstSelected) return [firstSelected.id];
+			return [];
+		});
+	}, [enabledControls, multiple]);
+	const getAnswerByElement = useCallback((element) => enabledControls.find((control) => control.element === element) ?? null, [enabledControls]);
+	const getAnswerByShortcut = useCallback((shortcut) => {
+		if (shortcutByChoiceValue) {
+			let choiceValue;
+			for (const [value, key] of shortcutByChoiceValue) if (key === shortcut) {
+				choiceValue = value;
+				break;
+			}
+			return enabledControls.find((control) => control.type === "choice" && control.value === choiceValue) ?? null;
+		}
+		let answerId;
+		for (const [id, key] of shortcutByAnswerId) if (key === shortcut) {
+			answerId = id;
+			break;
+		}
+		return enabledControls.find((control) => control.id === answerId) ?? null;
+	}, [
+		enabledControls,
+		shortcutByAnswerId,
+		shortcutByChoiceValue
+	]);
+	const moveAnswerFocus = useCallback((target, direction) => {
+		const index = enabledControls.findIndex((control) => control.element === target);
+		const current = enabledControls[index] ?? null;
+		const count = enabledControls.length;
+		if (!count || isTextEntry(target) && !isEmptyTextInput(current) || index < 0 && target !== itemElement) return false;
+		let nextControl;
+		if (index < 0) {
+			const edgeControl = direction === "next" ? enabledControls[0] : enabledControls[count - 1];
+			nextControl = enabledControls.find(isAnswered) ?? edgeControl;
+		} else nextControl = enabledControls[(index + (direction === "next" ? 1 : -1) + count) % count];
+		if (!nextControl || nextControl.element === target || index >= 0 && isRadio(target) && isRadio(nextControl.element)) return false;
+		nextControl.element.focus();
+		if (nextControl.type === "choice" && isRadio(nextControl.element)) nextControl.element.click();
+		return true;
+	}, [enabledControls, itemElement]);
+	const choicesKey = getChoicesKey(sortedControls);
+	const choices = useMemo(() => JSON.parse(choicesKey), [choicesKey]);
+	useLayoutEffect(() => {
+		itemApiRef.current = {
+			focus,
+			focusInvalid,
+			getAnswerByElement,
+			getAnswerByShortcut,
+			moveAnswerFocus,
+			reset,
+			skip,
+			validate
+		};
+	});
+	useLayoutEffect(() => {
+		if (!itemElement) return;
+		return registerItem({
+			choices,
+			disabled,
+			element: itemElement,
+			focus: () => itemApiRef.current.focus(),
+			focusInvalid: () => itemApiRef.current.focusInvalid(),
+			getAnswerByElement: (element) => itemApiRef.current.getAnswerByElement(element),
+			getAnswerByShortcut: (shortcut) => itemApiRef.current.getAnswerByShortcut(shortcut),
+			moveAnswerFocus: (target, direction) => itemApiRef.current.moveAnswerFocus(target, direction),
+			name,
+			required,
+			reset: () => itemApiRef.current.reset(),
+			skip: () => itemApiRef.current.skip(),
+			status,
+			validate: () => itemApiRef.current.validate()
+		});
+	}, [
+		choices,
+		disabled,
+		itemElement,
+		name,
+		registerItem,
+		required,
+		status
+	]);
+	const context = useMemo(() => ({
+		active,
+		disabled,
+		hasInputAnswer,
+		invalid: showInvalid,
+		multiple,
+		name,
+		registerAnswerControl,
+		registerAnswerSelection,
+		registerDescription,
+		registerError,
+		required,
+		resetVersion,
+		selectedAnswerIds,
+		setAnswerDefault,
+		setAnswerSelectionFromInteraction,
+		shortcutByAnswerId,
+		shortcutByChoiceValue,
+		shortcuts,
+		status,
+		syncControlledAnswerSelection
+	}), [
+		active,
+		disabled,
+		hasInputAnswer,
+		showInvalid,
+		multiple,
+		name,
+		registerAnswerControl,
+		registerAnswerSelection,
+		registerDescription,
+		registerError,
+		required,
+		resetVersion,
+		selectedAnswerIds,
+		setAnswerDefault,
+		setAnswerSelectionFromInteraction,
+		shortcutByAnswerId,
+		shortcutByChoiceValue,
+		shortcuts,
+		status,
+		syncControlledAnswerSelection
+	]);
+	const describedByIds = [...descriptionIds];
+	if (showInvalid) describedByIds.push(...errorIds);
+	describedByIds.push(ariaDescribedBy ?? "");
+	const keyShortcuts = [ariaKeyShortcuts];
+	if (active) {
+		keyShortcuts.push("Meta+Enter Control+Enter");
+		if (enabledControls.length) keyShortcuts.push("ArrowUp ArrowDown");
+		if (!first) keyShortcuts.push("ArrowLeft");
+		if (!last && status !== "unanswered") keyShortcuts.push("ArrowRight");
+	}
+	return {
+		context,
+		setItemElement,
+		itemProps: {
+			"aria-describedby": joinTokens(describedByIds),
+			"aria-invalid": showInvalid || void 0,
+			"aria-keyshortcuts": joinTokens(keyShortcuts),
+			"disabled": disabled,
+			"hidden": !active,
+			"inert": !active,
+			"tabIndex": -1
+		},
+		state: {
+			active,
+			disabled,
+			invalid: showInvalid,
+			multiple,
+			required,
+			status
+		}
+	};
+}
+/**
+* Логика опроса: открытый вопрос, переходы, проверка, отправка и сброс, клавиатура
+* @param parameters - параметры опроса
+* @returns контекст, пропсы формы и состояние
+*/
+function useRoot({ defaultItem, item, items, noValidate, onItemChange, onReset, onSubmit, shortcuts }) {
+	const collection = useMemo(() => createItemCollection(items), [items]);
+	const [registeredItems, setRegisteredItems] = useState([]);
+	const [uncontrolledItem, setUncontrolledItem] = useState(() => resolveItemName(collection, defaultItem));
+	const [formElement, setFormElement] = useState(null);
+	const [domVersion, setDomVersion] = useState(0);
+	const pendingFocusRef = useRef(null);
+	const isControlled = item !== void 0;
+	const activeItemName = isControlled ? item : uncontrolledItem;
+	const previousItemRef = useRef(activeItemName);
+	const nativeValidation = !noValidate;
+	const shortcutMode = shortcuts ?? null;
+	const warningsRef = useRef(/* @__PURE__ */ new Set());
+	useLayoutEffect(() => {
+		if (!collection || !formElement) {
+			warningsRef.current.clear();
+			return;
+		}
+		let cancelled = false;
+		queueMicrotask(() => {
+			if (cancelled) return;
+			const warnings = /* @__PURE__ */ new Set([...getDefinitionWarnings(collection, defaultItem), ...getRenderWarnings(collection, registeredItems, shortcutMode)]);
+			for (const warning of warnings) if (!warningsRef.current.has(warning)) console.warn(`[Questionnaire] ${warning}`);
+			warningsRef.current = warnings;
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		collection,
+		defaultItem,
+		registeredItems,
+		formElement,
+		shortcutMode
+	]);
+	useLayoutEffect(() => {
+		if (!formElement || typeof MutationObserver === "undefined") return;
+		const observer = new MutationObserver(() => {
+			setDomVersion((previous) => previous + 1);
+		});
+		observer.observe(formElement, {
+			childList: true,
+			subtree: true
+		});
+		return () => observer.disconnect();
+	}, [formElement]);
+	const enabledRegistered = useMemo(() => {
+		const result = [];
+		for (const registered of registeredItems) if (!registered.disabled) result.push(registered);
+		return result.sort(compareByDocumentPosition);
+	}, [domVersion, registeredItems]);
+	const registeredByName = useMemo(() => {
+		const result = /* @__PURE__ */ new Map();
+		for (const registered of enabledRegistered) result.set(registered.name, registered);
+		return result;
+	}, [enabledRegistered]);
+	const orderedItems = collection?.enabledItems ?? enabledRegistered;
+	const activeIndex = orderedItems.findIndex((current) => current.name === activeItemName);
+	const activeItem = activeIndex < 0 || !activeItemName ? null : registeredByName.get(activeItemName) ?? null;
+	const activeDefinition = activeItemName ? collection?.itemByName.get(activeItemName) : void 0;
+	let activeItemRequired = null;
+	let activeItemStatus = null;
+	if (activeIndex >= 0) {
+		activeItemRequired = activeDefinition ? Boolean(activeDefinition.required) : activeItem?.required ?? false;
+		const fallbackStatus = activeItemName ? "unanswered" : null;
+		activeItemStatus = activeItem?.status ?? fallbackStatus;
+	}
+	const validationItems = useMemo(() => {
+		if (!collection) return enabledRegistered;
+		const result = [];
+		for (const definition of collection.enabledItems) {
+			const registered = registeredByName.get(definition.name);
+			if (registered) result.push(registered);
+		}
+		return result;
+	}, [
+		collection,
+		registeredByName,
+		enabledRegistered
+	]);
+	const total = orderedItems.length;
+	const current = activeIndex < 0 ? 0 : activeIndex + 1;
+	const first = total > 0 && activeIndex === 0;
+	const last = total > 0 && activeIndex === total - 1;
+	const openItem = useCallback((name, target = "item") => {
+		if (name === activeItemName) return;
+		pendingFocusRef.current = {
+			name,
+			target
+		};
+		if (!isControlled) setUncontrolledItem(name);
+		onItemChange?.(name);
+	}, [
+		activeItemName,
+		isControlled,
+		onItemChange
+	]);
+	const openItemAt = useCallback((index) => {
+		const target = orderedItems[index];
+		if (target) openItem(target.name);
+	}, [orderedItems, openItem]);
+	useLayoutEffect(() => {
+		if (total === 0) return;
+		if (activeIndex < 0) {
+			const firstName = orderedItems[0]?.name ?? "";
+			if (!isControlled && activeItemName === null) {
+				setUncontrolledItem(firstName);
+				return;
+			}
+			openItem(firstName);
+			return;
+		}
+		const pending = pendingFocusRef.current;
+		const changed = previousItemRef.current !== activeItemName;
+		previousItemRef.current = activeItemName;
+		if (!pending || pending.name !== activeItemName) {
+			if (isControlled && changed) {
+				pendingFocusRef.current = null;
+				activeItem?.focus();
+			}
+			return;
+		}
+		if (pending.target === "invalid") activeItem?.focusInvalid();
+		else activeItem?.focus();
+		pendingFocusRef.current = null;
+	}, [
+		activeItem,
+		activeItemName,
+		isControlled,
+		activeIndex,
+		orderedItems,
+		openItem,
+		total
+	]);
+	const registerItem = useCallback((registered) => {
+		setRegisteredItems((previous) => {
+			const result = [];
+			for (const current of previous) if (current.element !== registered.element && current.name !== registered.name) result.push(current);
+			result.push(registered);
+			return result;
+		});
+		return () => {
+			setRegisteredItems((previous) => previous.filter((current) => current !== registered));
+		};
+	}, []);
+	const goPrevious = useCallback(() => {
+		if (activeIndex > 0) openItemAt(activeIndex - 1);
+	}, [activeIndex, openItemAt]);
+	const goNext = useCallback(() => {
+		if (!activeItem || activeIndex >= total - 1) return;
+		if (!activeItem.validate()) {
+			activeItem.focusInvalid();
+			return;
+		}
+		openItemAt(activeIndex + 1);
+	}, [
+		activeItem,
+		activeIndex,
+		openItemAt,
+		total
+	]);
+	const advance = useCallback(() => {
+		if (!activeItem) return;
+		if (!activeItem.validate()) {
+			activeItem.focusInvalid();
+			return;
+		}
+		if (last) {
+			formElement?.requestSubmit();
+			return;
+		}
+		openItemAt(activeIndex + 1);
+	}, [
+		activeItem,
+		activeIndex,
+		last,
+		formElement,
+		openItemAt
+	]);
+	const skipCurrent = useCallback(() => {
+		if (!activeItem || activeItem.required) return;
+		activeItem.skip();
+		if (!last) {
+			openItemAt(activeIndex + 1);
+			return;
+		}
+		queueMicrotask(() => {
+			formElement?.requestSubmit();
+		});
+	}, [
+		activeItem,
+		activeIndex,
+		last,
+		formElement,
+		openItemAt
+	]);
+	/**
+	* Сброс формы: ответы к начальным, открыть начальный вопрос
+	* @param event - событие reset
+	*/
+	const handleReset = (event) => {
+		onReset?.(event);
+		if (event.defaultPrevented) return;
+		for (const registered of registeredItems) registered.reset();
+		let resetName;
+		if (collection) resetName = resolveItemName(collection, defaultItem);
+		else resetName = enabledRegistered.find((registered) => registered.name === defaultItem)?.name ?? enabledRegistered[0]?.name;
+		if (resetName) openItem(resetName);
+	};
+	/**
+	* Отправка формы: открыть первый вопрос с ошибкой или передать событие дальше
+	* @param event - событие submit
+	*/
+	const handleSubmit = (event) => {
+		const invalidItem = validationItems.find((registered) => !registered.validate());
+		if (invalidItem) {
+			event.preventDefault();
+			openItem(invalidItem.name, "invalid");
+			if (invalidItem.name === activeItemName) {
+				invalidItem.focusInvalid();
+				pendingFocusRef.current = null;
+			}
+			return;
+		}
+		onSubmit?.(event);
+	};
+	/**
+	* Клавиатура: Ctrl/Cmd+Enter и Enter — дальше, стрелки — ответы и вопросы, буквы/цифры — варианты
+	* @param event - событие клавиатуры
+	*/
+	const handleKeyDown = (event) => {
+		const { key, target } = event;
+		if (event.defaultPrevented || event.nativeEvent.isComposing || event.keyCode === 229) return;
+		if (!activeItem || !(target instanceof Element)) return;
+		if (key === "Enter" && (event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey) {
+			event.preventDefault();
+			if (!event.repeat) advance();
+			return;
+		}
+		if (event.metaKey || event.ctrlKey || event.altKey) return;
+		if (key === "ArrowUp" || key === "ArrowDown") {
+			const direction = key === "ArrowDown" ? "next" : "previous";
+			if (activeItem.moveAnswerFocus(target, direction)) {
+				event.preventDefault();
+				return;
+			}
+		}
+		if ((key === "ArrowLeft" || key === "ArrowRight") && !isTextEntry(target) && !isRadio(target)) {
+			event.preventDefault();
+			if (event.repeat) return;
+			if (key === "ArrowLeft") goPrevious();
+			else if (activeItem.status !== "unanswered") goNext();
+			return;
+		}
+		if (key === "Enter") {
+			const answer = activeItem.getAnswerByElement(target);
+			if (!answer) return;
+			event.preventDefault();
+			if (!event.repeat && isAnswered(answer)) advance();
+			return;
+		}
+		if (!shortcutMode || isTextEntry(target)) return;
+		const shortcut = getShortcutByKey(key, shortcutMode);
+		const answer = shortcut ? activeItem.getAnswerByShortcut(shortcut) : null;
+		if (!answer) return;
+		event.preventDefault();
+		if (event.repeat) return;
+		answer.element.focus();
+		if (answer.type === "choice") answer.element.click();
+	};
+	const state = {
+		current,
+		first,
+		last,
+		total
+	};
+	const itemDefinitionByName = collection?.itemByName ?? null;
+	return {
+		context: useMemo(() => ({
+			current,
+			first,
+			last,
+			total,
+			activeItem,
+			activeItemName,
+			activeItemRequired,
+			activeItemStatus,
+			domVersion,
+			goNext,
+			goPrevious,
+			itemDefinitionByName,
+			nativeValidation,
+			registerItem,
+			shortcuts: shortcutMode,
+			skipCurrent
+		}), [
+			activeItem,
+			activeItemName,
+			activeItemRequired,
+			activeItemStatus,
+			itemDefinitionByName,
+			current,
+			domVersion,
+			first,
+			goNext,
+			goPrevious,
+			last,
+			nativeValidation,
+			registerItem,
+			shortcutMode,
+			skipCurrent,
+			total
+		]),
+		setFormElement,
+		rootProps: {
+			"data-shortcuts": shortcutMode ?? void 0,
+			"onKeyDown": handleKeyDown,
+			"onReset": handleReset,
+			"onSubmit": handleSubmit
+		},
+		state
+	};
+}
+/**
+* Корень опроса: форма
+* @param props - пропсы корня
+* @returns форма с контекстом опроса
+*/
+function Root({ defaultItem, item, items, noValidate = true, onItemChange, onReset, onSubmit, ref, shortcuts, ...props }) {
+	const { context, setFormElement, rootProps, state } = useRoot({
+		defaultItem,
+		item,
+		items,
+		noValidate,
+		onItemChange,
+		onReset,
+		onSubmit,
+		shortcuts
+	});
+	const element = useRender({
+		defaultTagName: "form",
+		ref: [setFormElement, ref ?? null],
+		state,
+		props: mergeProps({
+			...rootProps,
+			noValidate
+		}, props)
+	});
+	return createElement(RootContext, { value: context }, element);
+}
+/**
+* Прогресс опроса: role=progressbar с номером вопроса
+* @param props - пропсы прогресса
+* @returns индикатор прогресса
+*/
+function Progress({ render, ref, ...props }) {
+	const { current, first, last, total } = useRootContext("QuestionnaireProgress");
+	const hasItems = total > 0;
+	return useRender({
+		defaultTagName: "div",
+		render,
+		ref,
+		state: {
+			current,
+			first,
+			last,
+			total
+		},
+		props: mergeProps({
+			"aria-live": "polite",
+			"aria-valuemax": hasItems ? total : void 0,
+			"aria-valuemin": hasItems ? 1 : void 0,
+			"aria-valuenow": hasItems ? current : void 0,
+			"role": "progressbar"
+		}, props)
+	});
+}
+/**
+* Вопрос: fieldset, виден, только пока открыт
+* @param props - пропсы вопроса
+* @returns вопрос с контекстом
+*/
+function Item({ "aria-describedby": ariaDescribedBy, "aria-keyshortcuts": ariaKeyShortcuts, disabled = false, invalid = false, multiple = false, name, onStatusChange, ref, required = false, ...props }) {
+	const { context, setItemElement, itemProps, state } = useItem({
+		ariaDescribedBy,
+		ariaKeyShortcuts,
+		disabled,
+		invalid,
+		multiple,
+		name,
+		onStatusChange,
+		required
+	});
+	const element = useRender({
+		defaultTagName: "fieldset",
+		ref: [setItemElement, ref ?? null],
+		state,
+		stateAttributesMapping: { active: (value) => value ? { "data-active": "" } : null },
+		props: mergeProps(itemProps, props)
+	});
+	return createElement(ItemContext, { value: context }, element);
+}
+/**
+* Заголовок вопроса: legend
+* @param props - пропсы заголовка
+* @returns legend
+*/
+function Title({ render, ref, ...props }) {
+	useItemContext("QuestionnaireTitle");
+	return useRender({
+		defaultTagName: "legend",
+		render,
+		ref,
+		props
+	});
+}
+/**
+* Описание вопроса: попадает в aria-describedby вопроса
+* @param props - пропсы описания
+* @returns абзац
+*/
+function Description({ id, render, ref, ...props }) {
+	const { registerDescription } = useItemContext("QuestionnaireDescription");
+	const generatedId = useId();
+	const descriptionId = id ?? generatedId;
+	useLayoutEffect(() => registerDescription(descriptionId), [descriptionId, registerDescription]);
+	return useRender({
+		defaultTagName: "p",
+		render,
+		ref,
+		props: mergeProps({ id: descriptionId }, props)
+	});
+}
+/**
+* Список вариантов
+* @param props - пропсы списка
+* @returns div
+*/
+function Choices({ render, ref, ...props }) {
+	const { shortcuts } = useItemContext("QuestionnaireChoices");
+	return useRender({
+		defaultTagName: "div",
+		render,
+		ref,
+		state: { shortcuts },
+		props
+	});
+}
+/**
+* Атрибуты выбранного и невыбранного варианта
+* @param checked - вариант выбран
+* @returns data-checked или data-unchecked
+*/
+function getCheckedAttributes(checked) {
+	if (checked) return { "data-checked": "" };
+	return { "data-unchecked": "" };
+}
+/**
+* Вариант ответа: label вокруг input
+* @param props - пропсы варианта
+* @returns label с контекстом варианта
+*/
+function Choice({ checked, defaultChecked = false, disabled = false, onChange, render, ref, value, ...props }) {
+	const choice = useChoice({
+		checked,
+		defaultChecked,
+		disabled,
+		onChange,
+		value
+	});
+	const element = useRender({
+		defaultTagName: "label",
+		render,
+		ref,
+		state: choice.state,
+		stateAttributesMapping: { checked: getCheckedAttributes },
+		props
+	});
+	return createElement(ChoiceContext, { value: choice }, element);
+}
+/**
+* input варианта: радиокнопка или флажок
+* @param props - пропсы input
+* @returns input
+*/
+function ChoiceInput({ render, ref, ...props }) {
+	const { inputProps, state } = useChoiceContext("QuestionnaireChoiceInput");
+	const { ref: inputRef, ...ownProps } = inputProps;
+	return useRender({
+		defaultTagName: "input",
+		render,
+		ref: [inputRef, ref ?? null],
+		state,
+		stateAttributesMapping: { checked: getCheckedAttributes },
+		props: mergeProps(ownProps, props)
+	});
+}
+/**
+* Подпись варианта
+* @param props - пропсы подписи
+* @returns span
+*/
+function ChoiceLabel({ render, ref, ...props }) {
+	useChoiceContext("QuestionnaireChoiceLabel");
+	return useRender({
+		defaultTagName: "span",
+		render,
+		ref,
+		props
+	});
+}
+/**
+* Подсказка клавиши варианта: скрыта, если клавиши нет
+* @param props - пропсы подсказки
+* @returns span
+*/
+function ChoiceShortcut({ children, render, ref, ...props }) {
+	const { state } = useChoiceContext("QuestionnaireChoiceShortcut");
+	const { shortcut } = state;
+	return useRender({
+		defaultTagName: "span",
+		render,
+		ref,
+		state: { shortcut },
+		props: mergeProps({
+			"aria-hidden": true,
+			"children": children ?? shortcut,
+			"hidden": shortcut === null
+		}, props)
+	});
+}
+/**
+* Атрибуты заполненного и пустого поля
+* @param filled - в поле есть текст
+* @returns data-filled или data-empty
+*/
+function getFilledAttributes(filled) {
+	if (filled) return { "data-filled": "" };
+	return { "data-empty": "" };
+}
+/**
+* Поле свободного ответа: ответ, только пока в нём есть текст
+* @param props - пропсы поля
+* @returns input
+*/
+function Input({ defaultValue, disabled = false, onChange, ref, render, type = "text", value, ...props }) {
+	const { inputRef, inputProps, state } = useInput({
+		defaultValue,
+		disabled,
+		onChange,
+		type,
+		value
+	});
+	return useRender({
+		defaultTagName: "input",
+		render,
+		ref: [inputRef, ref ?? null],
+		state,
+		stateAttributesMapping: { filled: getFilledAttributes },
+		props: mergeProps(inputProps, props)
+	});
+}
+/**
+* Ошибка вопроса: видна, когда ответ не прошёл проверку
+* @param props - пропсы ошибки
+* @returns абзац с role=alert
+*/
+function ErrorMessage({ id, render, ref, ...props }) {
+	const { invalid, registerError } = useItemContext("QuestionnaireError");
+	const generatedId = useId();
+	const errorId = id ?? generatedId;
+	const role = invalid ? "alert" : void 0;
+	useLayoutEffect(() => registerError(errorId), [errorId, registerError]);
+	return useRender({
+		defaultTagName: "p",
+		render,
+		ref,
+		state: { invalid },
+		props: mergeProps({
+			hidden: !invalid,
+			id: errorId,
+			role
+		}, props)
+	});
+}
+/**
+* Атрибуты видимой и скрытой кнопки
+* @param visible - кнопка видна
+* @returns data-visible или data-hidden
+*/
+function getVisibleAttributes(visible) {
+	if (visible) return { "data-visible": "" };
+	return { "data-hidden": "" };
+}
+/**
+* Кнопка навигации: скрыта и недоступна, когда неприменима
+* @param parameters - параметры кнопки
+* @returns кнопка
+*/
+function useNavigationButton({ props, onClick, shortcut, status, visible }) {
+	const { disabled = false, render, ref, tabIndex, ...ownProps } = props;
+	const activeShortcut = visible && !disabled ? shortcut ?? null : null;
+	return useRender({
+		defaultTagName: "button",
+		render,
+		ref,
+		state: {
+			disabled,
+			shortcut: activeShortcut,
+			status,
+			visible
+		},
+		stateAttributesMapping: { visible: getVisibleAttributes },
+		props: mergeProps({
+			"aria-hidden": !visible || void 0,
+			"aria-keyshortcuts": activeShortcut ?? void 0,
+			"disabled": disabled,
+			"hidden": !visible,
+			"inert": !visible,
+			"onClick": onClick,
+			"tabIndex": visible ? tabIndex : -1
+		}, ownProps)
+	});
+}
+/**
+* Кнопка «Назад»: видна, если открыт не первый вопрос
+* @param props - пропсы кнопки
+* @returns кнопка
+*/
+function Previous({ onClick, type = "button", ...props }) {
+	const root = useRootContext("QuestionnairePrevious");
+	/**
+	* Нажатие: к предыдущему вопросу
+	* @param event - событие клика
+	*/
+	const handleClick = (event) => {
+		onClick?.(event);
+		if (!event.defaultPrevented) root.goPrevious();
+	};
+	return useNavigationButton({
+		props: {
+			...props,
+			type
+		},
+		onClick: handleClick,
+		status: root.activeItemStatus,
+		visible: root.total > 1 && !root.first
+	});
+}
+/**
+* Кнопка «Пропустить»: видна у необязательного вопроса
+* @param props - пропсы кнопки
+* @returns кнопка
+*/
+function Skip({ onClick, type = "button", ...props }) {
+	const root = useRootContext("QuestionnaireSkip");
+	/**
+	* Нажатие: пропустить вопрос
+	* @param event - событие клика
+	*/
+	const handleClick = (event) => {
+		onClick?.(event);
+		if (!event.defaultPrevented) root.skipCurrent();
+	};
+	return useNavigationButton({
+		props: {
+			...props,
+			type
+		},
+		onClick: handleClick,
+		status: root.activeItemStatus,
+		visible: root.activeItemRequired === false
+	});
+}
+/**
+* Кнопка «Далее»: видна, если открыт не последний вопрос
+* @param props - пропсы кнопки
+* @returns кнопка
+*/
+function Next({ onClick, type = "button", ...props }) {
+	const root = useRootContext("QuestionnaireNext");
+	/**
+	* Нажатие: к следующему вопросу
+	* @param event - событие клика
+	*/
+	const handleClick = (event) => {
+		onClick?.(event);
+		if (!event.defaultPrevented) root.goNext();
+	};
+	return useNavigationButton({
+		props: {
+			...props,
+			type
+		},
+		onClick: handleClick,
+		shortcut: "Enter",
+		status: root.activeItemStatus,
+		visible: root.total > 1 && !root.last
+	});
+}
+/**
+* Кнопка отправки: видна на последнем вопросе
+* @param props - пропсы кнопки
+* @returns кнопка
+*/
+function Submit({ type = "submit", ...props }) {
+	const root = useRootContext("QuestionnaireSubmit");
+	return useNavigationButton({
+		props: {
+			...props,
+			type
+		},
+		shortcut: "Enter",
+		status: root.activeItemStatus,
+		visible: root.total > 0 && root.last
+	});
+}
+/** Части опроса без оформления */
+const QuestionnairePrimitive = {
+	Root,
+	Progress,
+	Item,
+	Title,
+	Description,
+	Choices,
+	Choice,
+	ChoiceInput,
+	ChoiceLabel,
+	ChoiceShortcut,
+	Input,
+	Error: ErrorMessage,
+	Previous,
+	Skip,
+	Next,
+	Submit
+};
+export { QuestionnairePrimitive };