@shtabapp/ui-kit 1.85.0 → 1.85.1

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

@@ -0,0 +1,222 @@
+import { TABLE_SCROLL_IDENTITY_EDGE, TABLE_SCROLL_PROBE_HEIGHT, TABLE_SCROLL_UI_HEIGHT_HEADROOM, TABLE_SCROLL_UI_HEIGHT_SAFE } from "../constants/tableSizes.js";
+import { computed, onMounted, shallowRef, toValue, watch } from "vue";
+import { tryOnScopeDispose, useEventListener } from "@vueuse/core";
+//#region src/components/STable/utils/useTableScrollScale.ts
+var probedMaxElementHeight;
+/**
+* Предел высоты элемента у браузера: offsetHeight пробного div насыщается на лимите
+* LayoutUnit. Меряется один раз на документ и только когда таблица к нему подходит.
+*/
+var probeMaxElementHeight = () => {
+	if (probedMaxElementHeight !== void 0) return probedMaxElementHeight;
+	if (typeof document === "undefined") {
+		probedMaxElementHeight = TABLE_SCROLL_UI_HEIGHT_SAFE;
+		return probedMaxElementHeight;
+	}
+	const probe = document.createElement("div");
+	probe.style.cssText = `position:absolute;visibility:hidden;pointer-events:none;width:1px;height:${TABLE_SCROLL_PROBE_HEIGHT}px`;
+	document.body.appendChild(probe);
+	const measuredHeight = probe.offsetHeight;
+	probe.remove();
+	probedMaxElementHeight = measuredHeight > 0 ? measuredHeight : TABLE_SCROLL_UI_HEIGHT_SAFE;
+	return probedMaxElementHeight;
+};
+/** Потолок UI-высоты tbody; ниже SAFE проба не запускается. */
+var resolveUiHeightCap = (modelHeight) => {
+	return modelHeight > 16e6 ? probeMaxElementHeight() - TABLE_SCROLL_UI_HEIGHT_HEADROOM : Number.POSITIVE_INFINITY;
+};
+/** Ширина краевых зон: вьюпорт или константа, если между ними остаётся средняя зона. */
+var resolveEdgeZone = (active, viewport, maxUiScrollTop) => {
+	if (!active) return 0;
+	const edgeZone = Math.max(viewport, TABLE_SCROLL_IDENTITY_EDGE);
+	return maxUiScrollTop > 4 * edgeZone ? edgeZone : 0;
+};
+var mapUiToModel = (scale, uiOffset) => {
+	if (!scale.active) return uiOffset;
+	if (uiOffset <= scale.edgeZone) return uiOffset;
+	if (uiOffset >= scale.maxUiScrollTop - scale.edgeZone) return Math.min(scale.maxModelScrollTop, scale.maxModelScrollTop - (scale.maxUiScrollTop - uiOffset));
+	return scale.edgeZone + (uiOffset - scale.edgeZone) * scale.ratio;
+};
+var mapModelToUi = (scale, modelOffset) => {
+	if (!scale.active) return modelOffset;
+	if (modelOffset <= scale.edgeZone) return Math.max(0, modelOffset);
+	if (modelOffset >= scale.maxModelScrollTop - scale.edgeZone) return Math.min(scale.maxUiScrollTop, scale.maxUiScrollTop - (scale.maxModelScrollTop - modelOffset));
+	return scale.edgeZone + (modelOffset - scale.edgeZone) / scale.ratio;
+};
+var isSameScale = (next, prev) => {
+	return next.active === prev.active && next.maxUiScrollTop === prev.maxUiScrollTop && next.maxModelScrollTop === prev.maxModelScrollTop && next.edgeZone === prev.edgeZone;
+};
+/** Перепривязка нужна, если карта изменилась и хотя бы одна из сторон — сжатая. */
+var needsRescale = (next, prev) => {
+	return !isSameScale(next, prev) && (next.active || prev.active);
+};
+/**
+* Сжатие прокрутки для таблиц выше лимита браузера (ag-grid-style): высота tbody в DOM
+* ограничена потолком, scrollTop скроллера («UI») переводится в модельный офсет, а строки
+* раскладываются по UI-координатам как `модель − uiShift`. Карта кусочная: краевые зоны
+* один к одному, середина — пропорционально. Пока таблица ниже потолка — тождество.
+*/
+var useTableScrollScale = ({ scrollElement, totalSize, viewportHeight, extraHeight, onRescale }) => {
+	const uiScrollTop = shallowRef(0);
+	const scale = computed(() => {
+		const modelHeight = toValue(totalSize);
+		const extra = toValue(extraHeight);
+		const viewport = toValue(viewportHeight);
+		const cap = resolveUiHeightCap(modelHeight);
+		const active = modelHeight > cap;
+		const uiHeight = active ? cap : modelHeight;
+		const maxUiScrollTop = Math.max(1, uiHeight + extra - viewport);
+		const maxModelScrollTop = Math.max(0, modelHeight + extra - viewport);
+		const edgeZone = resolveEdgeZone(active, viewport, maxUiScrollTop);
+		return {
+			active,
+			uiHeight,
+			maxUiScrollTop,
+			maxModelScrollTop,
+			edgeZone,
+			ratio: active ? (maxModelScrollTop - 2 * edgeZone) / (maxUiScrollTop - 2 * edgeZone) : 1
+		};
+	});
+	const uiToModel = (uiOffset) => {
+		return mapUiToModel(scale.value, uiOffset);
+	};
+	const modelToUi = (modelOffset) => {
+		return mapModelToUi(scale.value, modelOffset);
+	};
+	const anchorModelOffset = shallowRef(0);
+	const anchorUiScrollTop = shallowRef(-1);
+	useEventListener(scrollElement, "scroll", () => {
+		const container = scrollElement.value;
+		if (!container) return;
+		uiScrollTop.value = container.scrollTop;
+		if (container.scrollTop !== anchorUiScrollTop.value) {
+			anchorUiScrollTop.value = container.scrollTop;
+			anchorModelOffset.value = uiToModel(container.scrollTop);
+		}
+	}, { passive: true });
+	/**
+	* Модельный офсет по живому DOM. Якорь берётся, только если браузер показывает именно
+	* нашу запись: он магнитит scrollTop к своей сетке (offset во float32, у потолка
+	* прокрутки шаг доходит до 2 UI-px), и обратный перевод увёл бы модель на шаг × ratio —
+	* строки уезжали бы на пару пикселей за каждую перепривязку. Сверка идёт с DOM, а не с
+	* зеркалом `uiScrollTop`: оно отстаёт на одно scroll-событие (событие асинхронно), и
+	* слепая вера в якорь откатывала бы прокрутку, попавшую в этот зазор.
+	*/
+	const resolveModelOffset = (container) => {
+		return container.scrollTop === anchorUiScrollTop.value ? anchorModelOffset.value : uiToModel(container.scrollTop);
+	};
+	/**
+	* Раскладка при сжатии идёт от якоря: computed не имеет права читать DOM, поэтому
+	* сверку с ним делает `resolveModelOffset` — им пользуются все, кто пишет позицию.
+	* Без сжатия якорь не участвует вовсе: модель тождественна scrollTop.
+	*/
+	const modelScrollOffset = computed(() => {
+		return scale.value.active ? anchorModelOffset.value : uiToModel(uiScrollTop.value);
+	});
+	/** Сдвиг раскладки: сколько модельных пикселей «спрятано» выше текущего scrollTop. */
+	const uiShift = computed(() => {
+		return scale.value.active ? modelScrollOffset.value - uiScrollTop.value : 0;
+	});
+	const uiTotalSize = computed(() => {
+		return scale.value.uiHeight;
+	});
+	const maxModelScrollTop = computed(() => {
+		return scale.value.maxModelScrollTop;
+	});
+	const active = computed(() => {
+		return scale.value.active;
+	});
+	/**
+	* Программная прокрутка: scrollTop и его зеркало обновляются синхронно, чтобы рендер,
+	* идущий следом, раскладывал спейсеры уже под новую позицию, а не под прошлую.
+	* `modelOffset` — намеренная модельная позиция: она и становится якорем, иначе
+	* примагниченный браузером scrollTop переводился бы обратно с потерей точности.
+	* Намерению верим, только если запись действительно легла: магничение к сетке она
+	* пережить обязана, а вот в скрытом контейнере (`display: none`, ещё не применённая
+	* высота) scrollTop остаётся прежним — якорь ушёл бы в намерение, uiShift отрисовал бы
+	* дальние строки при ползунке вверху, и первая же прокрутка вернула бы всё рывком.
+	*/
+	const setScrollTop = (container, uiOffset, modelOffset) => {
+		container.scrollTop = uiOffset;
+		uiScrollTop.value = container.scrollTop;
+		anchorUiScrollTop.value = container.scrollTop;
+		anchorModelOffset.value = modelOffset !== void 0 && Math.abs(container.scrollTop - uiOffset) <= 4 ? Math.max(0, Math.min(scale.value.maxModelScrollTop, modelOffset)) : uiToModel(container.scrollTop);
+	};
+	/** Размер «страницы» по оси: высота вьюпорта или ширина скроллера. */
+	const resolveWheelPageSize = (axis) => {
+		if (axis === "y") return toValue(viewportHeight);
+		return scrollElement.value?.clientWidth ?? 0;
+	};
+	/** Пикселей в одной единице дельты: LINE — строка, PAGE — вьюпорт по оси. */
+	const resolveWheelUnitPx = (deltaMode, axis) => {
+		if (deltaMode === WheelEvent.DOM_DELTA_LINE) return 40;
+		return deltaMode === WheelEvent.DOM_DELTA_PAGE ? resolveWheelPageSize(axis) : 1;
+	};
+	/**
+	* Дельта колеса в px: строчный и страничный режимы переводятся по строке и вьюпорту.
+	* Переводить нужно обе оси: `preventDefault` снимает нативный обработчик, который сделал
+	* бы это сам, и сырая `deltaX` в строчном режиме (обычная мышь в Firefox) двигала бы
+	* таблицу вбок на единицы пикселей вместо строк.
+	*/
+	const resolveWheelDeltaPx = (event, axis) => {
+		return (axis === "x" ? event.deltaX : event.deltaY) * resolveWheelUnitPx(event.deltaMode, axis);
+	};
+	const isModelWheel = (event) => {
+		return scale.value.active && event.deltaY !== 0 && !event.ctrlKey;
+	};
+	/**
+	* Колесо при сжатии — в модельных px: иначе тик листал бы в ratio раз больше строк,
+	* чем в той же таблице без сжатия. Горизонтальная дельта отдаётся скроллеру как есть.
+	*/
+	const handleWheel = (event) => {
+		const container = scrollElement.value;
+		if (!container || !isModelWheel(event)) return;
+		const { maxModelScrollTop: maxOffset } = scale.value;
+		const previousModelOffset = resolveModelOffset(container);
+		const modelOffset = Math.max(0, Math.min(maxOffset, previousModelOffset + resolveWheelDeltaPx(event, "y")));
+		if (modelOffset === previousModelOffset) return;
+		event.preventDefault();
+		setScrollTop(container, modelToUi(modelOffset), modelOffset);
+		container.scrollLeft += resolveWheelDeltaPx(event, "x");
+	};
+	let stopWheelListener;
+	const syncWheelListener = (isActive) => {
+		stopWheelListener?.();
+		stopWheelListener = isActive ? useEventListener(scrollElement, "wheel", handleWheel, { passive: false }) : void 0;
+	};
+	tryOnScopeDispose(() => {
+		stopWheelListener?.();
+	});
+	/**
+	* Модельный офсет для перепривязки — сверка с DOM по ПРОШЛОЙ карте: scrollTop ещё
+	* относится к ней, а `resolveModelOffset` мапил бы уже по новой. Иначе прокрутка,
+	* чьё scroll-событие не успело прийти к смене карты, потерялась бы на перепривязке.
+	*/
+	const resolveRescaleOffset = (container, prev) => {
+		return container.scrollTop === anchorUiScrollTop.value ? anchorModelOffset.value : mapUiToModel(prev, container.scrollTop);
+	};
+	onMounted(() => {
+		watch(scale, (next, prev) => {
+			const container = scrollElement.value;
+			if (!container || !needsRescale(next, prev)) return;
+			const modelOffset = resolveRescaleOffset(container, prev);
+			setScrollTop(container, mapModelToUi(next, modelOffset), modelOffset);
+			onRescale?.(modelOffset);
+		});
+		watch(active, syncWheelListener, { immediate: true });
+	});
+	return {
+		uiScrollTop,
+		modelScrollOffset,
+		uiShift,
+		uiTotalSize,
+		maxModelScrollTop,
+		active,
+		uiToModel,
+		modelToUi,
+		resolveModelOffset,
+		setScrollTop
+	};
+};
+//#endregion
+export { useTableScrollScale };

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

@@ -0,0 +1,137 @@
+const require_STable_types = require("../STable.types.cjs");
+const require_useFlatTableRows = require("./useFlatTableRows.cjs");
+let vue = require("vue");
+//#region src/components/STable/utils/useTableSelection.ts
+/**
+* Выбор строк с опциональным каскадом (tri-state):
+* - в `selected` живут только selectable-узлы (группы и disabled исключены);
+* - checked = сам узел в наборе; indeterminate = узел не в наборе, но есть выбранные потомки;
+* - каскадный клик кладёт/убирает всё selectable-поддерево, авто-подъём достраивает предков.
+*/
+var useTableSelection = ({ selected, cascade, treeIndex, groupRow, disabledKey, isItemSelectable }) => {
+	const selectedKeySet = (0, vue.computed)(() => {
+		return new Set(selected.value);
+	});
+	const getParentKey = (rowKey) => {
+		return treeIndex.value.nodeByKey.get(rowKey)?.parentKey;
+	};
+	const isNodeSelectable = (rowKey) => {
+		const node = treeIndex.value.nodeByKey.get(rowKey);
+		if (!node) return false;
+		if (require_useFlatTableRows.resolveTableBooleanField(node.item, (0, vue.toValue)(groupRow))) return false;
+		if (require_useFlatTableRows.resolveTableBooleanField(node.item, (0, vue.toValue)(disabledKey))) return false;
+		const selectablePredicate = (0, vue.toValue)(isItemSelectable);
+		return selectablePredicate ? selectablePredicate(node.item) !== false : true;
+	};
+	const selectableKeys = (0, vue.computed)(() => {
+		const allKeys = [];
+		treeIndex.value.nodeByKey.forEach((_node, rowKey) => {
+			if (isNodeSelectable(rowKey)) allKeys.push(rowKey);
+		});
+		return (0, vue.markRaw)(allKeys);
+	});
+	/** Число выбранных потомков по ключу узла — для indeterminate. O(|selected| × depth). */
+	const selectedDescendantCountByKey = (0, vue.computed)(() => {
+		const descendantCountByKey = /* @__PURE__ */ new Map();
+		selectedKeySet.value.forEach((selectedKey) => {
+			let parentKey = getParentKey(selectedKey);
+			while (parentKey) {
+				descendantCountByKey.set(parentKey, (descendantCountByKey.get(parentKey) ?? 0) + 1);
+				parentKey = getParentKey(parentKey);
+			}
+		});
+		return (0, vue.markRaw)(descendantCountByKey);
+	});
+	const isSelected = (rowKey) => {
+		return selectedKeySet.value.has(rowKey);
+	};
+	const getCheckState = (rowKey) => {
+		if (selectedKeySet.value.has(rowKey)) return require_STable_types.ESTableCheckState.CHECKED;
+		if ((selectedDescendantCountByKey.value.get(rowKey) ?? 0) > 0) return require_STable_types.ESTableCheckState.INDETERMINATE;
+		return require_STable_types.ESTableCheckState.UNCHECKED;
+	};
+	const collectSelectableSubtreeKeys = (rowKey, subtreeKeys) => {
+		if (isNodeSelectable(rowKey)) subtreeKeys.push(rowKey);
+		treeIndex.value.nodeByKey.get(rowKey)?.children?.forEach((childNode) => {
+			collectSelectableSubtreeKeys(childNode.key, subtreeKeys);
+		});
+	};
+	/** Все ли selectable-дети узла в наборе (для авто-подъёма). */
+	const areAllChildrenSelected = (parentKey, selectedSet) => {
+		const children = treeIndex.value.nodeByKey.get(parentKey)?.children;
+		if (!children || children.length === 0) return false;
+		return children.every((childNode) => {
+			if (!isNodeSelectable(childNode.key)) return areAllChildrenSelected(childNode.key, selectedSet);
+			return selectedSet.has(childNode.key);
+		});
+	};
+	const raiseAncestors = (rowKey, selectedSet) => {
+		let parentKey = getParentKey(rowKey);
+		while (parentKey) {
+			if (isNodeSelectable(parentKey) && areAllChildrenSelected(parentKey, selectedSet)) selectedSet.add(parentKey);
+			else if (!isNodeSelectable(parentKey)) {} else break;
+			parentKey = getParentKey(parentKey);
+		}
+	};
+	const dropAncestors = (rowKey, selectedSet) => {
+		let parentKey = getParentKey(rowKey);
+		while (parentKey) {
+			selectedSet.delete(parentKey);
+			parentKey = getParentKey(parentKey);
+		}
+	};
+	const toggleRow = (rowKey) => {
+		if (!isNodeSelectable(rowKey)) return;
+		const selectedSet = new Set(selected.value);
+		if (!(0, vue.toValue)(cascade)) {
+			if (selectedSet.has(rowKey)) selectedSet.delete(rowKey);
+			else selectedSet.add(rowKey);
+			selected.value = [...selectedSet];
+			return;
+		}
+		const subtreeKeys = [];
+		collectSelectableSubtreeKeys(rowKey, subtreeKeys);
+		if (getCheckState(rowKey) === require_STable_types.ESTableCheckState.UNCHECKED) {
+			subtreeKeys.forEach((subtreeKey) => {
+				selectedSet.add(subtreeKey);
+			});
+			raiseAncestors(rowKey, selectedSet);
+		} else {
+			subtreeKeys.forEach((subtreeKey) => {
+				selectedSet.delete(subtreeKey);
+			});
+			dropAncestors(rowKey, selectedSet);
+		}
+		selected.value = [...selectedSet];
+	};
+	const headerCheckState = (0, vue.computed)(() => {
+		const selectableCount = selectableKeys.value.length;
+		const selectedVisibleCount = selectableKeys.value.reduce((count, selectableKey) => {
+			return selectedKeySet.value.has(selectableKey) ? count + 1 : count;
+		}, 0);
+		if (selectableCount === 0 || selectedVisibleCount === 0) return require_STable_types.ESTableCheckState.UNCHECKED;
+		if (selectedVisibleCount >= selectableCount) return require_STable_types.ESTableCheckState.CHECKED;
+		return require_STable_types.ESTableCheckState.INDETERMINATE;
+	});
+	const toggleSelectAll = () => {
+		if (headerCheckState.value === require_STable_types.ESTableCheckState.CHECKED) {
+			selected.value = [];
+			return;
+		}
+		selected.value = [...selectableKeys.value];
+	};
+	const clearSelection = () => {
+		selected.value = [];
+	};
+	return {
+		isSelected,
+		isNodeSelectable,
+		getCheckState,
+		toggleRow,
+		headerCheckState,
+		toggleSelectAll,
+		clearSelection
+	};
+};
+//#endregion
+exports.useTableSelection = useTableSelection;

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

@@ -0,0 +1,137 @@
+import { ESTableCheckState } from "../STable.types.js";
+import { resolveTableBooleanField } from "./useFlatTableRows.js";
+import { computed, markRaw, toValue } from "vue";
+//#region src/components/STable/utils/useTableSelection.ts
+/**
+* Выбор строк с опциональным каскадом (tri-state):
+* - в `selected` живут только selectable-узлы (группы и disabled исключены);
+* - checked = сам узел в наборе; indeterminate = узел не в наборе, но есть выбранные потомки;
+* - каскадный клик кладёт/убирает всё selectable-поддерево, авто-подъём достраивает предков.
+*/
+var useTableSelection = ({ selected, cascade, treeIndex, groupRow, disabledKey, isItemSelectable }) => {
+	const selectedKeySet = computed(() => {
+		return new Set(selected.value);
+	});
+	const getParentKey = (rowKey) => {
+		return treeIndex.value.nodeByKey.get(rowKey)?.parentKey;
+	};
+	const isNodeSelectable = (rowKey) => {
+		const node = treeIndex.value.nodeByKey.get(rowKey);
+		if (!node) return false;
+		if (resolveTableBooleanField(node.item, toValue(groupRow))) return false;
+		if (resolveTableBooleanField(node.item, toValue(disabledKey))) return false;
+		const selectablePredicate = toValue(isItemSelectable);
+		return selectablePredicate ? selectablePredicate(node.item) !== false : true;
+	};
+	const selectableKeys = computed(() => {
+		const allKeys = [];
+		treeIndex.value.nodeByKey.forEach((_node, rowKey) => {
+			if (isNodeSelectable(rowKey)) allKeys.push(rowKey);
+		});
+		return markRaw(allKeys);
+	});
+	/** Число выбранных потомков по ключу узла — для indeterminate. O(|selected| × depth). */
+	const selectedDescendantCountByKey = computed(() => {
+		const descendantCountByKey = /* @__PURE__ */ new Map();
+		selectedKeySet.value.forEach((selectedKey) => {
+			let parentKey = getParentKey(selectedKey);
+			while (parentKey) {
+				descendantCountByKey.set(parentKey, (descendantCountByKey.get(parentKey) ?? 0) + 1);
+				parentKey = getParentKey(parentKey);
+			}
+		});
+		return markRaw(descendantCountByKey);
+	});
+	const isSelected = (rowKey) => {
+		return selectedKeySet.value.has(rowKey);
+	};
+	const getCheckState = (rowKey) => {
+		if (selectedKeySet.value.has(rowKey)) return ESTableCheckState.CHECKED;
+		if ((selectedDescendantCountByKey.value.get(rowKey) ?? 0) > 0) return ESTableCheckState.INDETERMINATE;
+		return ESTableCheckState.UNCHECKED;
+	};
+	const collectSelectableSubtreeKeys = (rowKey, subtreeKeys) => {
+		if (isNodeSelectable(rowKey)) subtreeKeys.push(rowKey);
+		treeIndex.value.nodeByKey.get(rowKey)?.children?.forEach((childNode) => {
+			collectSelectableSubtreeKeys(childNode.key, subtreeKeys);
+		});
+	};
+	/** Все ли selectable-дети узла в наборе (для авто-подъёма). */
+	const areAllChildrenSelected = (parentKey, selectedSet) => {
+		const children = treeIndex.value.nodeByKey.get(parentKey)?.children;
+		if (!children || children.length === 0) return false;
+		return children.every((childNode) => {
+			if (!isNodeSelectable(childNode.key)) return areAllChildrenSelected(childNode.key, selectedSet);
+			return selectedSet.has(childNode.key);
+		});
+	};
+	const raiseAncestors = (rowKey, selectedSet) => {
+		let parentKey = getParentKey(rowKey);
+		while (parentKey) {
+			if (isNodeSelectable(parentKey) && areAllChildrenSelected(parentKey, selectedSet)) selectedSet.add(parentKey);
+			else if (!isNodeSelectable(parentKey)) {} else break;
+			parentKey = getParentKey(parentKey);
+		}
+	};
+	const dropAncestors = (rowKey, selectedSet) => {
+		let parentKey = getParentKey(rowKey);
+		while (parentKey) {
+			selectedSet.delete(parentKey);
+			parentKey = getParentKey(parentKey);
+		}
+	};
+	const toggleRow = (rowKey) => {
+		if (!isNodeSelectable(rowKey)) return;
+		const selectedSet = new Set(selected.value);
+		if (!toValue(cascade)) {
+			if (selectedSet.has(rowKey)) selectedSet.delete(rowKey);
+			else selectedSet.add(rowKey);
+			selected.value = [...selectedSet];
+			return;
+		}
+		const subtreeKeys = [];
+		collectSelectableSubtreeKeys(rowKey, subtreeKeys);
+		if (getCheckState(rowKey) === ESTableCheckState.UNCHECKED) {
+			subtreeKeys.forEach((subtreeKey) => {
+				selectedSet.add(subtreeKey);
+			});
+			raiseAncestors(rowKey, selectedSet);
+		} else {
+			subtreeKeys.forEach((subtreeKey) => {
+				selectedSet.delete(subtreeKey);
+			});
+			dropAncestors(rowKey, selectedSet);
+		}
+		selected.value = [...selectedSet];
+	};
+	const headerCheckState = computed(() => {
+		const selectableCount = selectableKeys.value.length;
+		const selectedVisibleCount = selectableKeys.value.reduce((count, selectableKey) => {
+			return selectedKeySet.value.has(selectableKey) ? count + 1 : count;
+		}, 0);
+		if (selectableCount === 0 || selectedVisibleCount === 0) return ESTableCheckState.UNCHECKED;
+		if (selectedVisibleCount >= selectableCount) return ESTableCheckState.CHECKED;
+		return ESTableCheckState.INDETERMINATE;
+	});
+	const toggleSelectAll = () => {
+		if (headerCheckState.value === ESTableCheckState.CHECKED) {
+			selected.value = [];
+			return;
+		}
+		selected.value = [...selectableKeys.value];
+	};
+	const clearSelection = () => {
+		selected.value = [];
+	};
+	return {
+		isSelected,
+		isNodeSelectable,
+		getCheckState,
+		toggleRow,
+		headerCheckState,
+		toggleSelectAll,
+		clearSelection
+	};
+};
+//#endregion
+export { useTableSelection };

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

@@ -0,0 +1,125 @@
+const require_useFlatTableRows = require("./useFlatTableRows.cjs");
+let vue = require("vue");
+//#region src/components/STable/utils/useTableServiceRows.ts
+/**
+* Служебные строки (группа, футер поддерева, «Показать ещё») и агрегатный футер.
+*
+* Общий принцип: контент такой строки живёт в конкретной колонке, а не растягивается
+* через `colspan` — колоночная структура сохраняется, и при горизонтальном скролле
+* контент не уезжает, потому что колонка по умолчанию главная и всегда sticky-left.
+*/
+var useTableServiceRows = ({ columns, primaryColumnKey, treeNodeByKey, groupTotalKey, depthFooter, groupContentColumnKey, creationContentColumnKey, loadMoreContentColumnKey, treeIndent, loadingMoreChildrenKeys, footerValues, stuckDepthFooterRowIndex, onDepthFooterClick, onLoadMoreChildren }) => {
+	const primaryColumn = (0, vue.computed)(() => {
+		return (0, vue.toValue)(columns).find((tableColumn) => tableColumn.key === primaryColumnKey.value);
+	});
+	const depthFooterColumnKey = (0, vue.computed)(() => {
+		return (0, vue.toValue)(depthFooter)?.columnKey ?? primaryColumnKey.value;
+	});
+	/** Колонка контента групповой строки (Figma: «Title row» живёт в главной колонке). */
+	const groupColumnKey = (0, vue.computed)(() => {
+		return (0, vue.toValue)(groupContentColumnKey) ?? primaryColumnKey.value;
+	});
+	const creationColumnKey = (0, vue.computed)(() => {
+		return (0, vue.toValue)(creationContentColumnKey) ?? primaryColumnKey.value;
+	});
+	const loadMoreColumnKey = (0, vue.computed)(() => {
+		return (0, vue.toValue)(loadMoreContentColumnKey) ?? primaryColumnKey.value;
+	});
+	const getGroupCount = (flatRow) => {
+		return treeNodeByKey.value.get(flatRow.key)?.subtreeSize ?? 0;
+	};
+	const getGroupTotal = (flatRow) => {
+		return require_useFlatTableRows.resolveTableNumberField(flatRow.item, (0, vue.toValue)(groupTotalKey));
+	};
+	const getGroupTitle = (flatRow) => {
+		const titleValue = require_useFlatTableRows.resolveTableCellValue(flatRow.item, primaryColumn.value?.value ?? primaryColumn.value?.key);
+		return titleValue === void 0 ? void 0 : String(titleValue);
+	};
+	/** Отступ уровня прибавляется к базовому паддингу контента ячейки. */
+	const getDepthIndentStyle = (depth) => {
+		return { paddingInlineStart: `calc(var(--s-ui-dimension-4) + ${depth * (0, vue.toValue)(treeIndent)}px)` };
+	};
+	const emitDepthFooterClick = (flatRow) => {
+		onDepthFooterClick({
+			parentKey: flatRow.parentKey ?? "",
+			parentItem: flatRow.item,
+			depth: flatRow.depth - 1
+		});
+	};
+	const getDepthFooterSlotScope = (flatRow) => {
+		return {
+			parentKey: flatRow.parentKey ?? "",
+			parentItem: flatRow.item,
+			depth: flatRow.depth - 1,
+			stuck: flatRow.index === stuckDepthFooterRowIndex.value,
+			click: () => {
+				emitDepthFooterClick(flatRow);
+			}
+		};
+	};
+	const loadingMoreChildrenKeySet = (0, vue.computed)(() => {
+		return new Set((0, vue.toValue)(loadingMoreChildrenKeys));
+	});
+	const isLoadMoreRowLoading = (flatRow) => {
+		if (!flatRow.parentKey) return false;
+		return loadingMoreChildrenKeySet.value.has(flatRow.parentKey);
+	};
+	const emitLoadMoreChildren = (flatRow) => {
+		if (!flatRow.parentKey || isLoadMoreRowLoading(flatRow)) return;
+		onLoadMoreChildren({
+			key: flatRow.parentKey,
+			item: flatRow.item
+		});
+	};
+	const getLoadMoreSlotScope = (flatRow) => {
+		return {
+			parentKey: flatRow.parentKey ?? "",
+			parentItem: flatRow.item,
+			depth: flatRow.depth,
+			loading: isLoadMoreRowLoading(flatRow),
+			loadMore: () => {
+				emitLoadMoreChildren(flatRow);
+			}
+		};
+	};
+	const getFooterValue = (columnKey) => {
+		return (0, vue.toValue)(footerValues)?.[columnKey];
+	};
+	const getFooterValueText = (columnKey) => {
+		const footerValue = getFooterValue(columnKey);
+		if (!footerValue) return "";
+		if (footerValue.limit !== void 0) return `${footerValue.value}/${footerValue.limit}`;
+		return String(footerValue.value);
+	};
+	/** Тон агрегата задаёт приложение: правило «когда предупреждать» — не зона кита. */
+	const getFooterToneClass = (columnKey) => {
+		const footerTone = getFooterValue(columnKey)?.tone;
+		return footerTone ? `s-ui-table__aggregate-cell--tone-${footerTone}` : void 0;
+	};
+	const getFooterSlotScope = (columnKey) => {
+		return {
+			column: (0, vue.toValue)(columns).find((tableColumn) => tableColumn.key === columnKey) ?? { key: columnKey },
+			footerValue: getFooterValue(columnKey)
+		};
+	};
+	return {
+		depthFooterColumnKey,
+		groupColumnKey,
+		creationColumnKey,
+		loadMoreColumnKey,
+		getGroupCount,
+		getGroupTotal,
+		getGroupTitle,
+		getDepthIndentStyle,
+		emitDepthFooterClick,
+		getDepthFooterSlotScope,
+		isLoadMoreRowLoading,
+		emitLoadMoreChildren,
+		getLoadMoreSlotScope,
+		getFooterValueText,
+		getFooterToneClass,
+		getFooterSlotScope
+	};
+};
+//#endregion
+exports.useTableServiceRows = useTableServiceRows;