@shtabapp/ui-kit 1.85.0 → 1.85.2

package/dist/components/STable/utils/useTableGridFocus.js

@@ -0,0 +1,398 @@
+import { ESTableRowKind } from "../STable.types.js";
+import { ESTableServiceColumn } from "./useTableColumns.js";
+import { computed, nextTick, shallowRef, toValue, watch } from "vue";
+//#region src/components/STable/utils/useTableGridFocus.ts
+/** Секции грида по вертикальной оси; значения совпадают с `data-section` в DOM. */
+var ESTableGridSection = /* @__PURE__ */ function(ESTableGridSection) {
+	ESTableGridSection["HEADER"] = "h";
+	ESTableGridSection["BODY"] = "b";
+	ESTableGridSection["CREATION"] = "c";
+	ESTableGridSection["AGGREGATE"] = "a";
+	return ESTableGridSection;
+}({});
+var GRID_INTERACTIVE_SELECTOR = "button, a[href], input, select, textarea, [tabindex]";
+var GRID_SECTIONS = Object.values(ESTableGridSection);
+/** Разбор `data-section` из DOM: значение приходит строкой, поэтому нужен guard. */
+var resolveTableGridSection = (value) => {
+	return GRID_SECTIONS.find((section) => section === value);
+};
+/**
+* Геометрия грида и DOM-фокус модели WAI-ARIA Grid: одна roving-ячейка на всю
+* таблицу, порядковая ось строк «шапка → тело → строка создания → агрегат».
+* Семантики клавиш здесь нет — её держит таблица.
+*/
+var useTableGridFocus = ({ tableRootElement, tableElement, exitElement, scrollElement, columnDescriptors, flatRows, snapshot, groupColumnKey, depthFooterColumnKey, loadMoreColumnKey, creationColumnKey, hasCreationRow, hasAggregateRow, isRowNavigable, pageSize, buildCellDomId, onBodyRowFocused, scrollToRowIndex }) => {
+	const storedAddress = shallowRef();
+	/** Память колонки: вертикальное движение возвращает в неё после узких строк. */
+	const desiredColumnKey = shallowRef();
+	const cellEntered = shallowRef(false);
+	/** Порядковый номер последнего адреса — якорь восстановления после размонтирования. */
+	const lastRowOrdinal = shallowRef(0);
+	/** Колонки, участвующие в навигации: без филлера и без декоративной полоски-индикатора. */
+	const navigableColumnKeys = computed(() => {
+		return columnDescriptors.value.filter((descriptor) => descriptor.service !== ESTableServiceColumn.INDICATOR).map((descriptor) => descriptor.key);
+	});
+	/** В теле и агрегате колонка управления колонками пуста — кнопка живёт только в шапке. */
+	const bodyNavigableColumnKeys = computed(() => {
+		return columnDescriptors.value.filter((descriptor) => {
+			return descriptor.service !== ESTableServiceColumn.INDICATOR && descriptor.service !== ESTableServiceColumn.COLUMNS_MANAGER;
+		}).map((descriptor) => descriptor.key);
+	});
+	const getRowByKey = (rowKey) => {
+		if (!rowKey) return;
+		const rowIndex = snapshot.value.getRowIndexByKey(rowKey);
+		return rowIndex === void 0 ? void 0 : flatRows.value[rowIndex];
+	};
+	/** У служебных строк контент живёт в одной колонке — остальные ячейки пустые. */
+	const getBodyRowColumnKeys = (flatRow) => {
+		if (flatRow.kind === ESTableRowKind.ROW) return bodyNavigableColumnKeys.value;
+		const contentColumnKey = {
+			[ESTableRowKind.ROW]: void 0,
+			[ESTableRowKind.GROUP]: toValue(groupColumnKey),
+			[ESTableRowKind.DEPTH_FOOTER]: toValue(depthFooterColumnKey),
+			[ESTableRowKind.LOAD_MORE]: toValue(loadMoreColumnKey)
+		}[flatRow.kind];
+		return contentColumnKey ? [contentColumnKey] : [];
+	};
+	const getAddressColumnKeys = (address) => {
+		if (address.section === "h") return navigableColumnKeys.value;
+		if (address.section === "c") {
+			const columnKey = toValue(creationColumnKey);
+			return toValue(hasCreationRow) && columnKey ? [columnKey] : [];
+		}
+		if (address.section === "a") return toValue(hasAggregateRow) ? bodyNavigableColumnKeys.value : [];
+		const flatRow = getRowByKey(address.rowKey);
+		return flatRow && isRowNavigable(flatRow) ? getBodyRowColumnKeys(flatRow) : [];
+	};
+	/** Подтягивание памяти колонки к ближайшей доступной в строке. */
+	const clampColumnKey = (columnKeys, preferredKey) => {
+		if (preferredKey && columnKeys.includes(preferredKey)) return preferredKey;
+		const orderedKeys = navigableColumnKeys.value;
+		const preferredIndex = preferredKey ? orderedKeys.indexOf(preferredKey) : -1;
+		const firstKey = columnKeys[0] ?? "";
+		if (preferredIndex === -1) return firstKey;
+		let closestKey = firstKey;
+		let closestDistance = Number.POSITIVE_INFINITY;
+		columnKeys.forEach((columnKey) => {
+			const distance = Math.abs(orderedKeys.indexOf(columnKey) - preferredIndex);
+			if (distance < closestDistance) {
+				closestDistance = distance;
+				closestKey = columnKey;
+			}
+		});
+		return closestKey;
+	};
+	const headerAddress = computed(() => {
+		return {
+			section: "h",
+			columnKey: clampColumnKey(navigableColumnKeys.value, desiredColumnKey.value)
+		};
+	});
+	/**
+	* Адрес всегда указывает на существующую ячейку: строка могла уехать из данных,
+	* колонка — скрыться, поэтому хранимое значение прогоняется через геометрию.
+	*/
+	const focusAddress = computed(() => {
+		const address = storedAddress.value;
+		if (!address) return headerAddress.value;
+		const columnKeys = getAddressColumnKeys(address);
+		if (columnKeys.length === 0) return headerAddress.value;
+		if (columnKeys.includes(address.columnKey)) return address;
+		return {
+			...address,
+			columnKey: clampColumnKey(columnKeys, address.columnKey)
+		};
+	});
+	const bodyRowCount = computed(() => {
+		return flatRows.value.length;
+	});
+	/** Последний порядковый номер оси строк: 0 — шапка, 1..n — тело, дальше полосы tfoot. */
+	const lastGridOrdinal = computed(() => {
+		return bodyRowCount.value + (toValue(hasCreationRow) ? 1 : 0) + (toValue(hasAggregateRow) ? 1 : 0);
+	});
+	const getGridRowOrdinal = (address) => {
+		if (address.section === "h") return 0;
+		if (address.section === "c") return bodyRowCount.value + 1;
+		if (address.section === "a") return bodyRowCount.value + 1 + (toValue(hasCreationRow) ? 1 : 0);
+		const rowIndex = address.rowKey === void 0 ? void 0 : snapshot.value.getRowIndexByKey(address.rowKey);
+		return rowIndex === void 0 ? void 0 : rowIndex + 1;
+	};
+	const resolveAddressByOrdinal = (ordinal, preferredColumnKey) => {
+		if (ordinal <= 0) return {
+			section: "h",
+			columnKey: clampColumnKey(navigableColumnKeys.value, preferredColumnKey)
+		};
+		if (ordinal <= bodyRowCount.value) {
+			const flatRow = flatRows.value[ordinal - 1];
+			if (!flatRow || !isRowNavigable(flatRow)) return;
+			const columnKeys = getBodyRowColumnKeys(flatRow);
+			if (columnKeys.length === 0) return;
+			return {
+				section: "b",
+				rowKey: flatRow.key,
+				columnKey: clampColumnKey(columnKeys, preferredColumnKey)
+			};
+		}
+		if (toValue(hasCreationRow) && ordinal === bodyRowCount.value + 1) {
+			const columnKey = toValue(creationColumnKey);
+			return columnKey ? {
+				section: "c",
+				columnKey
+			} : void 0;
+		}
+		if (toValue(hasAggregateRow) && ordinal === lastGridOrdinal.value) return {
+			section: "a",
+			columnKey: clampColumnKey(navigableColumnKeys.value, preferredColumnKey)
+		};
+	};
+	/** Первый навигируемый адрес от порядкового номера в заданную сторону (пропуск disabled). */
+	const findAddressFromOrdinal = (startOrdinal, direction) => {
+		let ordinal = startOrdinal;
+		while (ordinal >= 0 && ordinal <= lastGridOrdinal.value) {
+			const address = resolveAddressByOrdinal(ordinal, desiredColumnKey.value);
+			if (address) return address;
+			ordinal += direction;
+		}
+	};
+	/** id ячейки строится из ключа строки и ключа колонки — переживает ремаунт пула. */
+	const queryCellElement = (address) => {
+		return document.getElementById(buildCellDomId(address)) ?? void 0;
+	};
+	const queryFocusedCellElement = () => {
+		return queryCellElement(focusAddress.value);
+	};
+	/**
+	* Горизонтальный доскролл считается вручную с вычетом sticky-зон: `scrollIntoView`
+	* тут нельзя — он подрался бы с виртуализатором по вертикали.
+	*/
+	const ensureFocusedCellVisibleHorizontally = () => {
+		const container = scrollElement.value;
+		const cellElement = queryFocusedCellElement();
+		if (!container || !cellElement) return;
+		if (cellElement.classList.contains("s-ui-table__cell--sticky-left") || cellElement.classList.contains("s-ui-table__cell--sticky-right")) return;
+		const containerRect = container.getBoundingClientRect();
+		const rootElement = tableRootElement.value;
+		let leftBound = containerRect.left;
+		let rightBound = containerRect.right;
+		const lastStickyLeft = rootElement?.querySelector("th.s-ui-table__cell--last-sticky-left");
+		if (lastStickyLeft) leftBound = Math.max(leftBound, lastStickyLeft.getBoundingClientRect().right);
+		const firstStickyRight = rootElement?.querySelector("th.s-ui-table__cell--first-sticky-right");
+		if (firstStickyRight) rightBound = Math.min(rightBound, firstStickyRight.getBoundingClientRect().left);
+		const cellRect = cellElement.getBoundingClientRect();
+		if (cellRect.left < leftBound) {
+			container.scrollLeft -= leftBound - cellRect.left;
+			return;
+		}
+		if (cellRect.right > rightBound) container.scrollLeft += cellRect.right - rightBound;
+	};
+	const setAddress = (address, updateDesired) => {
+		storedAddress.value = address;
+		if (updateDesired) desiredColumnKey.value = address.columnKey;
+		const ordinal = getGridRowOrdinal(address);
+		if (ordinal !== void 0) lastRowOrdinal.value = ordinal;
+	};
+	const focusAddressNow = (address, options) => {
+		const columnKeys = getAddressColumnKeys(address);
+		const targetAddress = columnKeys.length > 0 && !columnKeys.includes(address.columnKey) ? {
+			...address,
+			columnKey: clampColumnKey(columnKeys, address.columnKey)
+		} : address;
+		setAddress(targetAddress, options?.updateDesired ?? true);
+		cellEntered.value = false;
+		if (targetAddress.section === "b" && targetAddress.rowKey) {
+			onBodyRowFocused(targetAddress.rowKey);
+			const rowIndex = snapshot.value.getRowIndexByKey(targetAddress.rowKey);
+			if ((options?.scroll ?? true) && rowIndex !== void 0) scrollToRowIndex(rowIndex);
+		}
+		if (options?.focusElement === false) return;
+		nextTick(() => {
+			queryFocusedCellElement()?.focus({ preventScroll: true });
+			ensureFocusedCellVisibleHorizontally();
+		});
+	};
+	const moveFocus = (rowDelta, columnDelta) => {
+		const address = focusAddress.value;
+		if (columnDelta !== 0) {
+			const columnKeys = getAddressColumnKeys(address);
+			const nextColumnKey = columnKeys[columnKeys.indexOf(address.columnKey) + columnDelta];
+			if (nextColumnKey) focusAddressNow({
+				...address,
+				columnKey: nextColumnKey
+			});
+			return;
+		}
+		if (rowDelta === 0) return;
+		const direction = rowDelta > 0 ? 1 : -1;
+		const nextAddress = findAddressFromOrdinal((getGridRowOrdinal(address) ?? lastRowOrdinal.value) + direction, direction);
+		if (nextAddress) focusAddressNow(nextAddress, { updateDesired: false });
+	};
+	const moveToRowEdge = (edge) => {
+		const address = focusAddress.value;
+		const columnKeys = getAddressColumnKeys(address);
+		const columnKey = edge === "start" ? columnKeys[0] : columnKeys[columnKeys.length - 1];
+		if (columnKey) focusAddressNow({
+			...address,
+			columnKey
+		});
+	};
+	const moveToGridEdge = (edge) => {
+		const address = edge === "first" ? findAddressFromOrdinal(0, 1) : findAddressFromOrdinal(lastGridOrdinal.value, -1);
+		if (!address) return;
+		const columnKeys = getAddressColumnKeys(address);
+		const columnKey = edge === "first" ? columnKeys[0] : columnKeys[columnKeys.length - 1];
+		focusAddressNow(columnKey ? {
+			...address,
+			columnKey
+		} : address);
+	};
+	const moveByPage = (direction) => {
+		const currentOrdinal = getGridRowOrdinal(focusAddress.value) ?? lastRowOrdinal.value;
+		const step = Math.max(1, Math.round(toValue(pageSize)));
+		const targetOrdinal = Math.min(lastGridOrdinal.value, Math.max(0, currentOrdinal + direction * step));
+		const nextAddress = findAddressFromOrdinal(targetOrdinal, direction) ?? findAddressFromOrdinal(targetOrdinal, direction === 1 ? -1 : 1);
+		if (nextAddress) focusAddressNow(nextAddress, { updateDesired: false });
+	};
+	/**
+	* Интерактивы ячейки. Скрытые до ховера зоны гасятся прозрачностью, а не
+	* `display: none`, поэтому `offsetParent` у них не null и кнопки находятся.
+	*/
+	const queryCellInteractives = (cellElement) => {
+		const interactives = [];
+		cellElement.querySelectorAll(GRID_INTERACTIVE_SELECTOR).forEach((element) => {
+			if (!(element instanceof HTMLElement) || element.offsetParent === null) return;
+			if (element.hasAttribute("disabled") || element.closest("[aria-hidden=\"true\"]")) return;
+			interactives.push(element);
+		});
+		return interactives;
+	};
+	/** Вход в ячейку; false — интерактивов нет, вызывающий делает своё действие. */
+	const enterCell = () => {
+		const cellElement = queryFocusedCellElement();
+		const firstInteractive = cellElement ? queryCellInteractives(cellElement)[0] : void 0;
+		if (!firstInteractive) return false;
+		cellEntered.value = true;
+		firstInteractive.focus();
+		return true;
+	};
+	const exitCell = () => {
+		cellEntered.value = false;
+		queryFocusedCellElement()?.focus({ preventScroll: true });
+	};
+	/**
+	* Tab внутри ячейки: к соседнему интерактиву ячейки. Без заворота — false с края, и
+	* вызывающий уводит фокус из грида (WCAG 2.1.2: Tab не ходит по кругу в ячейке).
+	*/
+	const moveCellFocus = (direction) => {
+		const cellElement = queryFocusedCellElement();
+		const interactives = cellElement ? queryCellInteractives(cellElement) : [];
+		const activeElement = document.activeElement;
+		const currentIndex = interactives.findIndex((element) => {
+			return element === activeElement || activeElement instanceof Node && element.contains(activeElement);
+		});
+		const nextInteractive = currentIndex === -1 ? void 0 : interactives[currentIndex + direction];
+		if (!nextInteractive) return false;
+		nextInteractive.focus();
+		return true;
+	};
+	/**
+	* Грид — одна остановка Tab: фокус встаёт на его границу (сама таблица перед ячейками или
+	* элемент-выход после неё), а дальше обход ведёт браузер действием Tab по умолчанию.
+	*/
+	const leaveGrid = (direction) => {
+		cellEntered.value = false;
+		(direction === 1 ? exitElement.value : tableElement.value)?.focus({ preventScroll: true });
+	};
+	/**
+	* Восстановление после размонтирования: тот же ключ строки → ближайший живой
+	* порядковый номер → шапка → сама таблица (у неё остаётся `tabindex="-1"`).
+	*/
+	const restoreFocusAfterUnmount = () => {
+		const address = focusAddress.value;
+		const columnKeys = getAddressColumnKeys(address);
+		if (columnKeys.length > 0) {
+			focusAddressNow({
+				...address,
+				columnKey: clampColumnKey(columnKeys, desiredColumnKey.value)
+			}, {
+				scroll: false,
+				updateDesired: false
+			});
+			return;
+		}
+		const fallbackOrdinal = Math.min(lastRowOrdinal.value, lastGridOrdinal.value);
+		const fallbackAddress = findAddressFromOrdinal(fallbackOrdinal, -1) ?? findAddressFromOrdinal(fallbackOrdinal, 1);
+		if (fallbackAddress) {
+			focusAddressNow(fallbackAddress, {
+				scroll: false,
+				updateDesired: false
+			});
+			return;
+		}
+		if (navigableColumnKeys.value.length > 0) {
+			focusAddressNow(headerAddress.value, {
+				scroll: false,
+				updateDesired: false
+			});
+			return;
+		}
+		tableElement.value?.focus();
+	};
+	/**
+	* Строка, ушедшая из данных (свернули родителя, отфильтровали, удалили), уносит
+	* с собой DOM-узел, и фокус падает в body — навигация обрывается на середине.
+	* Проверка на body намеренно узкая: если пользователь ушёл фокусом в другое
+	* место страницы, забирать фокус обратно нельзя.
+	*/
+	watch(() => {
+		const rowKey = storedAddress.value?.rowKey;
+		return rowKey === void 0 ? void 0 : snapshot.value.getRowIndexByKey(rowKey);
+	}, (rowIndex, previousRowIndex) => {
+		if (previousRowIndex === void 0 || rowIndex !== void 0) return;
+		if (document.activeElement !== document.body) return;
+		restoreFocusAfterUnmount();
+	}, { flush: "post" });
+	/** Синхронизация адреса из DOM-события фокуса — без повторного `.focus()`. */
+	const syncFocusAddress = (address, entered) => {
+		setAddress(address, true);
+		cellEntered.value = entered;
+		if (address.section === "b" && address.rowKey) onBodyRowFocused(address.rowKey);
+	};
+	const isCellFocused = (section, rowKey, columnKey) => {
+		const address = focusAddress.value;
+		return address.section === section && address.rowKey === rowKey && address.columnKey === columnKey;
+	};
+	/** Единственный `tabindex="0"` грида стоит на roving-ячейке. */
+	const getCellTabIndex = (section, rowKey, columnKey) => {
+		return isCellFocused(section, rowKey, columnKey) ? 0 : -1;
+	};
+	const focusedBodyRowKey = computed(() => {
+		const address = focusAddress.value;
+		return address.section === "b" ? address.rowKey : void 0;
+	});
+	return {
+		focusAddress,
+		focusedBodyRowKey,
+		focusBodyRowIndex: computed(() => {
+			const rowKey = focusedBodyRowKey.value;
+			return rowKey === void 0 ? void 0 : snapshot.value.getRowIndexByKey(rowKey);
+		}),
+		cellEntered,
+		isCellFocused,
+		getCellTabIndex,
+		moveFocus,
+		moveToRowEdge,
+		moveToGridEdge,
+		moveByPage,
+		focusAddressNow,
+		syncFocusAddress,
+		enterCell,
+		exitCell,
+		moveCellFocus,
+		leaveGrid,
+		restoreFocusAfterUnmount,
+		ensureFocusedCellVisibleHorizontally,
+		queryFocusedCellElement
+	};
+};
+//#endregion
+export { ESTableGridSection, resolveTableGridSection, useTableGridFocus };

package/dist/components/STable/utils/useTableGridKeyboard.cjs

@@ -0,0 +1,224 @@
+const require_treeKeyboardNavigation = require("../../../composables/treeKeyboardNavigation.cjs");
+const require_STable_types = require("../STable.types.cjs");
+const require_useTableGridFocus = require("./useTableGridFocus.cjs");
+let vue = require("vue");
+//#region src/components/STable/utils/useTableGridKeyboard.ts
+var GRID_TEXT_ENTRY_SELECTOR = "input, textarea, select, [contenteditable=\"true\"]";
+/**
+* Клавиатурный диспетчер грида: разбирает событие и переводит его в вызовы
+* `useTableGridFocus` и коллбэки таблицы. Собственного состояния не держит —
+* адрес фокуса и режим «внутри ячейки» живут в `useTableGridFocus`.
+*/
+var useTableGridKeyboard = ({ gridFocus, columnDescriptors, flatRows, expandColumnKey, primaryColumnKey, groupColumnKey, selectable, openMenuColumnKey, toggleExpanded, toggleRowSelected, applySortCycle, setColumnMenuOpen, resizeColumnByKeyboard, onDepthFooterActivate, onLoadMoreActivate, onRowActivate }) => {
+	const getFocusedDescriptor = () => {
+		const columnKey = gridFocus.focusAddress.value.columnKey;
+		return columnDescriptors.value.find((descriptor) => descriptor.key === columnKey);
+	};
+	const getFocusedBodyRow = () => {
+		const rowIndex = gridFocus.focusBodyRowIndex.value;
+		return rowIndex === void 0 ? void 0 : flatRows.value[rowIndex];
+	};
+	const resolveTreeColumnKey = (flatRow) => {
+		return flatRow.kind === require_STable_types.ESTableRowKind.GROUP ? (0, vue.toValue)(groupColumnKey) : (0, vue.toValue)(expandColumnKey) ?? (0, vue.toValue)(primaryColumnKey);
+	};
+	/**
+	* Ссылка или кнопка в ячейке — своя остановка Tab в документе, и обход снаружи встаёт на
+	* неё, минуя roving-ячейку. Вход с клавиатуры (`:focus-visible`) извне таблицы в чужую
+	* ячейку переводится на roving-ячейку. Мышь, программный фокус изнутри и поля ввода
+	* (у них `:focus-visible` и от мыши) остаются, где встали.
+	*/
+	const isKeyboardEntryPastRovingCell = (event, eventTarget, address) => {
+		const gridElement = event.currentTarget;
+		const previousElement = event.relatedTarget;
+		return !(gridElement instanceof Node && previousElement instanceof Node && gridElement.contains(previousElement)) && eventTarget.matches(":focus-visible") && !eventTarget.matches(GRID_TEXT_ENTRY_SELECTOR) && !gridFocus.isCellFocused(address.section, address.rowKey, address.columnKey);
+	};
+	/** Адрес ячейки из её `data-*`; null — элемент не ячейка грида. */
+	const resolveCellAddress = (cellElement) => {
+		const section = require_useTableGridFocus.resolveTableGridSection(cellElement.dataset.section ?? null);
+		const columnKey = cellElement.dataset.columnKey;
+		if (!section || !columnKey) return null;
+		return {
+			section,
+			rowKey: cellElement.dataset.rowKey,
+			columnKey
+		};
+	};
+	/** Фокус пришёл мышью или из ячейки — адрес модели догоняет DOM. */
+	const handleGridFocusIn = (event) => {
+		const eventTarget = event.target;
+		if (!(eventTarget instanceof HTMLElement)) return;
+		const cellElement = eventTarget.closest("[data-section]");
+		const address = cellElement instanceof HTMLElement ? resolveCellAddress(cellElement) : null;
+		if (!address) return;
+		const isInsideCell = cellElement !== eventTarget;
+		if (isInsideCell && isKeyboardEntryPastRovingCell(event, eventTarget, address)) {
+			gridFocus.focusAddressNow(gridFocus.focusAddress.value, { scroll: false });
+			return;
+		}
+		gridFocus.syncFocusAddress(address, isInsideCell);
+	};
+	/**
+	* Контракт treegrid: на колонке дерева ArrowRight раскрывает узел или уходит к первому
+	* потомку, ArrowLeft сворачивает или уходит к родителю. На остальных колонках стрелки
+	* остаются обычной навигацией грида. Возвращает true, если действие дерева применено.
+	*/
+	const handleTreeHorizontalKeydown = (key) => {
+		const address = gridFocus.focusAddress.value;
+		if (address.section !== require_useTableGridFocus.ESTableGridSection.BODY || !address.rowKey) return false;
+		const flatRow = getFocusedBodyRow();
+		if (!flatRow || flatRow.kind === require_STable_types.ESTableRowKind.DEPTH_FOOTER) return false;
+		if (address.columnKey !== resolveTreeColumnKey(flatRow)) return false;
+		const action = require_treeKeyboardNavigation.resolveTreeKeyboardNavigationAction(key, flatRow.key, flatRows.value);
+		if (!action) return false;
+		if (action.type === "select") {
+			gridFocus.focusAddressNow({
+				section: require_useTableGridFocus.ESTableGridSection.BODY,
+				rowKey: action.rowKey,
+				columnKey: address.columnKey
+			});
+			return true;
+		}
+		toggleExpanded(action.rowKey);
+		return true;
+	};
+	/** Enter на ячейке: сначала действие строки, иначе — вход внутрь ячейки. */
+	const activateFocusedCell = (event) => {
+		const address = gridFocus.focusAddress.value;
+		if (address.section === require_useTableGridFocus.ESTableGridSection.HEADER) {
+			const descriptor = getFocusedDescriptor();
+			if (descriptor?.sortable) {
+				applySortCycle(descriptor.key, event.shiftKey || event.ctrlKey || event.metaKey);
+				return;
+			}
+			gridFocus.enterCell();
+			return;
+		}
+		const flatRow = getFocusedBodyRow();
+		if (!flatRow) {
+			gridFocus.enterCell();
+			return;
+		}
+		if (flatRow.kind === require_STable_types.ESTableRowKind.DEPTH_FOOTER) {
+			onDepthFooterActivate(flatRow);
+			return;
+		}
+		if (flatRow.kind === require_STable_types.ESTableRowKind.LOAD_MORE) {
+			onLoadMoreActivate(flatRow);
+			return;
+		}
+		if ((flatRow.hasChildren || flatRow.kind === require_STable_types.ESTableRowKind.GROUP) && address.columnKey === resolveTreeColumnKey(flatRow)) {
+			toggleExpanded(flatRow.key);
+			return;
+		}
+		if (!gridFocus.enterCell()) onRowActivate(flatRow, event);
+	};
+	/**
+	* Tab: внутри ячейки — к соседнему её интерактиву, с края ячейки и с самой ячейки — из грида.
+	* На выходе действие по умолчанию не гасится: браузер продолжает обход от границы грида.
+	*/
+	const handleGridTab = (event) => {
+		if (event.defaultPrevented) return;
+		const direction = event.shiftKey ? -1 : 1;
+		if (gridFocus.cellEntered.value && gridFocus.moveCellFocus(direction)) {
+			event.preventDefault();
+			return;
+		}
+		gridFocus.leaveGrid(direction);
+	};
+	/** Внутри ячейки грид отдаёт клавиши её интерактиву; Escape возвращает на ячейку. */
+	const handleEnteredCellKeydown = (event) => {
+		if (event.key === "Escape") {
+			event.preventDefault();
+			gridFocus.exitCell();
+		}
+	};
+	/** Модификаторные сочетания разбираются до switch: они зависят от колонки, а не от клавиши. */
+	const handleColumnModifierKeydown = (event) => {
+		const descriptor = getFocusedDescriptor();
+		if (!descriptor) return false;
+		const isHorizontalArrow = event.key === "ArrowLeft" || event.key === "ArrowRight";
+		if (event.altKey && event.shiftKey && isHorizontalArrow) {
+			event.preventDefault();
+			resizeColumnByKeyboard(descriptor, event.key === "ArrowRight" ? 1 : -1);
+			return true;
+		}
+		const isMenuKey = event.altKey && event.key === "ArrowDown" || event.key === "ContextMenu";
+		const inHeader = gridFocus.focusAddress.value.section === require_useTableGridFocus.ESTableGridSection.HEADER;
+		if (descriptor.column && inHeader && isMenuKey) {
+			event.preventDefault();
+			setColumnMenuOpen(descriptor.key, (0, vue.toValue)(openMenuColumnKey) !== descriptor.key);
+			return true;
+		}
+		return false;
+	};
+	const handleGridKeydown = (event) => {
+		if (event.key === "Tab") {
+			handleGridTab(event);
+			return;
+		}
+		if (gridFocus.cellEntered.value) {
+			handleEnteredCellKeydown(event);
+			return;
+		}
+		if (handleColumnModifierKeydown(event)) return;
+		switch (event.key) {
+			case "ArrowRight":
+				event.preventDefault();
+				if (!handleTreeHorizontalKeydown("ArrowRight")) gridFocus.moveFocus(0, 1);
+				break;
+			case "ArrowLeft":
+				event.preventDefault();
+				if (!handleTreeHorizontalKeydown("ArrowLeft")) gridFocus.moveFocus(0, -1);
+				break;
+			case "ArrowDown":
+				event.preventDefault();
+				gridFocus.moveFocus(1, 0);
+				break;
+			case "ArrowUp":
+				event.preventDefault();
+				gridFocus.moveFocus(-1, 0);
+				break;
+			case "Home":
+				event.preventDefault();
+				if (event.ctrlKey || event.metaKey) gridFocus.moveToGridEdge("first");
+				else gridFocus.moveToRowEdge("start");
+				break;
+			case "End":
+				event.preventDefault();
+				if (event.ctrlKey || event.metaKey) gridFocus.moveToGridEdge("last");
+				else gridFocus.moveToRowEdge("end");
+				break;
+			case "PageDown":
+				event.preventDefault();
+				gridFocus.moveByPage(1);
+				break;
+			case "PageUp":
+				event.preventDefault();
+				gridFocus.moveByPage(-1);
+				break;
+			case "F2":
+				event.preventDefault();
+				gridFocus.enterCell();
+				break;
+			case "Enter":
+				event.preventDefault();
+				activateFocusedCell(event);
+				break;
+			case " ":
+			case "Spacebar": {
+				event.preventDefault();
+				const rowKey = gridFocus.focusedBodyRowKey.value;
+				if (!(0, vue.toValue)(selectable) || !rowKey) break;
+				toggleRowSelected(rowKey);
+				break;
+			}
+			default: break;
+		}
+	};
+	return {
+		handleGridFocusIn,
+		handleGridKeydown
+	};
+};
+//#endregion
+exports.useTableGridKeyboard = useTableGridKeyboard;