@feugene/granularity 0.13.0 → 0.18.0

package/dist/composables/useFloating.js

@@ -0,0 +1,133 @@
+import { n as openModalCount } from "../chunks/overlayStack-C8cfsqXa.js";
+import { nextTick, onBeforeUnmount, ref, watch } from "vue";
+import { autoUpdate, computePosition, flip, offset, shift, size } from "@floating-ui/dom";
+//#region src/composables/useFloating.ts
+/**
+* Device pixel ratio плавающего элемента. Нужен, чтобы округлять координаты к сетке
+* физических пикселей (см. `roundByDPR`) — иначе субпиксельные `left/top` дают размытый
+* текст/границы панели на не-целочисленных позициях и HiDPI-экранах. Подход перенят у
+* официального `@floating-ui/vue` (`useFloating` → `roundByDPR`), чтобы не тянуть весь
+* пакет ради одной утилиты.
+*/
+/**
+* Высота панели: своя шкала снаружи и подъём над окном внутри него.
+*
+* Панель телепортируется в общий портал, то есть становится **соседом** корня
+* модального окна, а не его потомком: собственный stacking-контекст окна её не
+* накрывает, и статический `--gr-z-dropdown` (1000) оставлял её под окном
+* (`--gr-z-modal`, 1100). Поэтому высоту берём из стека слоёв — единственного
+* места, которое знает, что сейчас открыто.
+*
+* Слагаемое — **число** модальных слоёв, а не шаг шкалы: вложенные окна дают
+* +2, а полноэкранная загрузка (1150) и тосты (1200) остаются сверху.
+*
+* Обратный случай — «поповер снаружи не должен перекрывать окно» — не страдает:
+* пока окно открыто, страница под ним в `inert`, и открыть там поповер нечем.
+* Ненулевой счётчик означает ровно «панель открыта изнутри окна».
+*/
+function floatingZIndex(zIndexVar) {
+	const modals = openModalCount();
+	return modals > 0 ? `calc(var(--gr-z-modal) + ${modals})` : `var(${zIndexVar})`;
+}
+function getDpr(element) {
+	if (typeof window === "undefined") return 1;
+	return (element.ownerDocument?.defaultView ?? window).devicePixelRatio || 1;
+}
+function roundByDpr(element, value) {
+	const dpr = getDpr(element);
+	return Math.round(value * dpr) / dpr;
+}
+/**
+* Единый движок позиционирования floating-панелей (Dropdown/Select/TreeSelect/Tooltip)
+* поверх `@floating-ui/dom`: flip (переворот при нехватке места), shift (клэмп к границам
+* viewport), опциональный `size`-мидлвар для растягивания по ширине триггера.
+*
+* Пересчёт положения при скролле/ресайзе делает `autoUpdate` из `@floating-ui/dom` —
+* он сам использует `ResizeObserver`/`IntersectionObserver` и пассивные слушатели вместо
+* наивного враппера на каждый `scroll`/`resize`, поэтому отдельный rAF-throttling здесь
+* не нужен (в отличие от прежней ручной реализации в `GrSelect`/`GrDropdown`).
+*
+* Требует, чтобы `floatingEl` был примонтирован в DOM на момент открытия (обычно —
+* `<teleport to="body">` + `v-show`, а не `v-if`): позиционирование не может измерить
+* элемент, которого нет в дереве.
+*/
+function useFloating(referenceEl, floatingEl, open, options = {}) {
+	const floatingStyle = ref({
+		position: "fixed",
+		top: "0px",
+		left: "0px"
+	});
+	function resolveRequestedPlacement() {
+		return typeof options.placement === "function" ? options.placement() : options.placement ?? "bottom-start";
+	}
+	function resolveMatchWidth() {
+		return typeof options.matchWidth === "function" ? options.matchWidth() : options.matchWidth ?? false;
+	}
+	const resolvedPlacement = ref(resolveRequestedPlacement());
+	let stopAutoUpdate = null;
+	async function update() {
+		const reference = referenceEl.value;
+		const floating = floatingEl.value;
+		if (!reference || !floating) return;
+		const middleware = [
+			offset(options.offsetPx ?? 8),
+			flip({ padding: options.boundaryPadding ?? 8 }),
+			shift({ padding: options.boundaryPadding ?? 8 })
+		];
+		const matchWidth = resolveMatchWidth();
+		if (matchWidth) middleware.push(size({ apply({ rects, elements }) {
+			if (matchWidth === "min") {
+				Object.assign(elements.floating.style, {
+					width: "max-content",
+					minWidth: `${rects.reference.width}px`
+				});
+				return;
+			}
+			Object.assign(elements.floating.style, {
+				width: `${rects.reference.width}px`,
+				minWidth: ""
+			});
+		} }));
+		const { x, y, placement } = await computePosition(reference, floating, {
+			placement: resolveRequestedPlacement(),
+			strategy: "fixed",
+			middleware
+		});
+		resolvedPlacement.value = placement;
+		floatingStyle.value = {
+			position: "fixed",
+			left: `${roundByDpr(floating, x)}px`,
+			top: `${roundByDpr(floating, y)}px`,
+			zIndex: floatingZIndex(options.zIndexVar ?? "--gr-z-dropdown")
+		};
+	}
+	function stop() {
+		stopAutoUpdate?.();
+		stopAutoUpdate = null;
+	}
+	function start() {
+		stop();
+		const reference = referenceEl.value;
+		const floating = floatingEl.value;
+		if (!reference || !floating) return;
+		update();
+		stopAutoUpdate = autoUpdate(reference, floating, () => void update());
+	}
+	watch(open, (isOpen) => {
+		if (!isOpen) {
+			stop();
+			return;
+		}
+		nextTick(() => {
+			if (open.value) start();
+		});
+	}, { immediate: true });
+	onBeforeUnmount(stop);
+	return {
+		floatingStyle,
+		resolvedPlacement,
+		update: () => void update()
+	};
+}
+//#endregion
+export { useFloating };

package/dist/composables/useFloating.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFloating.js","names":[],"sources":["../../src/composables/useFloating.ts"],"sourcesContent":["import type { CSSProperties, Ref } from 'vue'\nimport type { Middleware, Placement } from '@floating-ui/dom'\nimport { autoUpdate, computePosition, flip, offset as offsetMiddleware, shift, size as sizeMiddleware } from '@floating-ui/dom'\nimport { nextTick, onBeforeUnmount, ref, watch } from 'vue'\n\nimport { openModalCount } from './internal/overlayStack'\n\nexport type UseFloatingPlacement = Placement\n\n/**\n * Device pixel ratio плавающего элемента. Нужен, чтобы округлять координаты к сетке\n * физических пикселей (см. `roundByDPR`) — иначе субпиксельные `left/top` дают размытый\n * текст/границы панели на не-целочисленных позициях и HiDPI-экранах. Подход перенят у\n * официального `@floating-ui/vue` (`useFloating` → `roundByDPR`), чтобы не тянуть весь\n * пакет ради одной утилиты.\n */\n/**\n * Высота панели: своя шкала снаружи и подъём над окном внутри него.\n *\n * Панель телепортируется в общий портал, то есть становится **соседом** корня\n * модального окна, а не его потомком: собственный stacking-контекст окна её не\n * накрывает, и статический `--gr-z-dropdown` (1000) оставлял её под окном\n * (`--gr-z-modal`, 1100). Поэтому высоту берём из стека слоёв — единственного\n * места, которое знает, что сейчас открыто.\n *\n * Слагаемое — **число** модальных слоёв, а не шаг шкалы: вложенные окна дают\n * +2, а полноэкранная загрузка (1150) и тосты (1200) остаются сверху.\n *\n * Обратный случай — «поповер снаружи не должен перекрывать окно» — не страдает:\n * пока окно открыто, страница под ним в `inert`, и открыть там поповер нечем.\n * Ненулевой счётчик означает ровно «панель открыта изнутри окна».\n */\nfunction floatingZIndex(zIndexVar: string): string {\n  const modals = openModalCount()\n\n  return modals > 0 ? `calc(var(--gr-z-modal) + ${modals})` : `var(${zIndexVar})`\n}\n\nfunction getDpr(element: HTMLElement): number {\n  if (typeof window === 'undefined')\n    return 1\n\n  const win = element.ownerDocument?.defaultView ?? window\n  return win.devicePixelRatio || 1\n}\n\nfunction roundByDpr(element: HTMLElement, value: number): number {\n  const dpr = getDpr(element)\n  return Math.round(value * dpr) / dpr\n}\n\nexport interface UseFloatingOptions {\n  /**\n   * Предпочитаемое место панели относительно триггера. По умолчанию `bottom-start`.\n   * Можно передать функцию-геттер, если место зависит от реактивного пропа\n   * (например, `align`) — она вызывается заново при каждом пересчёте позиции.\n   */\n  placement?: UseFloatingPlacement | (() => UseFloatingPlacement)\n  /** Зазор между триггером и панелью, px. По умолчанию `8`. */\n  offsetPx?: number\n  /** Минимальный отступ от края viewport при flip/shift, px. По умолчанию `8`. */\n  boundaryPadding?: number\n  /**\n   * Согласовать ширину панели с шириной триггера (актуально для Select/TreeSelect).\n   * Не годится для Dropdown/Tooltip, где ширина панели определяется контентом.\n   * - `true` — точная ширина (`width = ширина триггера`);\n   * - `'min'` — панель растёт по контенту (`width: max-content`), но не уже триггера\n   *   (`min-width = ширина триггера`) — режим `GrSelect view=\"link\"`;\n   * - функция-геттер — как и `placement`, для реактивной зависимости от пропа.\n   */\n  matchWidth?: boolean | 'min' | (() => boolean | 'min')\n  /**\n   * CSS-переменная шкалы слоёв (см. `styles/tokens.css`). По умолчанию\n   * `--gr-z-dropdown`. Действует, пока панель открыта вне модального окна: над\n   * окном высоту задаёт стек слоёв (см. {@link floatingZIndex}).\n   */\n  zIndexVar?: string\n}\n\nexport interface UseFloatingReturn {\n  /** Готовый объект для `:style` на плавающем элементе. */\n  floatingStyle: Ref<CSSProperties>\n  /**\n   * Итоговое место панели ПОСЛЕ применения `flip` — может отличаться от запрошенного\n   * `placement`, если места не хватило и панель перевернуло на противоположную сторону.\n   * Полезно для выбора `transform-origin`/направления transition в потребителе.\n   */\n  resolvedPlacement: Ref<Placement>\n  /** Принудительный пересчёт позиции (например, после изменения контента панели). */\n  update: () => void\n}\n\n/**\n * Единый движок позиционирования floating-панелей (Dropdown/Select/TreeSelect/Tooltip)\n * поверх `@floating-ui/dom`: flip (переворот при нехватке места), shift (клэмп к границам\n * viewport), опциональный `size`-мидлвар для растягивания по ширине триггера.\n *\n * Пересчёт положения при скролле/ресайзе делает `autoUpdate` из `@floating-ui/dom` —\n * он сам использует `ResizeObserver`/`IntersectionObserver` и пассивные слушатели вместо\n * наивного враппера на каждый `scroll`/`resize`, поэтому отдельный rAF-throttling здесь\n * не нужен (в отличие от прежней ручной реализации в `GrSelect`/`GrDropdown`).\n *\n * Требует, чтобы `floatingEl` был примонтирован в DOM на момент открытия (обычно —\n * `<teleport to=\"body\">` + `v-show`, а не `v-if`): позиционирование не может измерить\n * элемент, которого нет в дереве.\n */\nexport function useFloating(\n  referenceEl: Ref<HTMLElement | null>,\n  floatingEl: Ref<HTMLElement | null>,\n  open: Ref<boolean>,\n  options: UseFloatingOptions = {},\n): UseFloatingReturn {\n  const floatingStyle = ref<CSSProperties>({\n    position: 'fixed',\n    top: '0px',\n    left: '0px',\n  })\n  function resolveRequestedPlacement(): Placement {\n    return typeof options.placement === 'function' ? options.placement() : options.placement ?? 'bottom-start'\n  }\n\n  function resolveMatchWidth(): boolean | 'min' {\n    return typeof options.matchWidth === 'function' ? options.matchWidth() : options.matchWidth ?? false\n  }\n\n  const resolvedPlacement = ref<Placement>(resolveRequestedPlacement())\n\n  let stopAutoUpdate: (() => void) | null = null\n\n  async function update(): Promise<void> {\n    const reference = referenceEl.value\n    const floating = floatingEl.value\n    if (!reference || !floating)\n      return\n\n    const middleware: Middleware[] = [\n      offsetMiddleware(options.offsetPx ?? 8),\n      flip({ padding: options.boundaryPadding ?? 8 }),\n      shift({ padding: options.boundaryPadding ?? 8 }),\n    ]\n\n    const matchWidth = resolveMatchWidth()\n    if (matchWidth) {\n      middleware.push(\n        sizeMiddleware({\n          apply({ rects, elements }) {\n            if (matchWidth === 'min') {\n              Object.assign(elements.floating.style, {\n                width: 'max-content',\n                minWidth: `${rects.reference.width}px`,\n              })\n              return\n            }\n\n            Object.assign(elements.floating.style, {\n              width: `${rects.reference.width}px`,\n              minWidth: '',\n            })\n          },\n        }),\n      )\n    }\n\n    const { x, y, placement } = await computePosition(reference, floating, {\n      placement: resolveRequestedPlacement(),\n      strategy: 'fixed',\n      middleware,\n    })\n\n    resolvedPlacement.value = placement\n    floatingStyle.value = {\n      position: 'fixed',\n      left: `${roundByDpr(floating, x)}px`,\n      top: `${roundByDpr(floating, y)}px`,\n      zIndex: floatingZIndex(options.zIndexVar ?? '--gr-z-dropdown'),\n    }\n  }\n\n  function stop(): void {\n    stopAutoUpdate?.()\n    stopAutoUpdate = null\n  }\n\n  function start(): void {\n    stop()\n    const reference = referenceEl.value\n    const floating = floatingEl.value\n    if (!reference || !floating)\n      return\n\n    // `autoUpdate` подписывается на `ResizeObserver`/`IntersectionObserver` для\n    // последующих пересчётов, но не гарантирует немедленный вызов `update` —\n    // особенно в средах без этих API (например, jsdom в тестах). Считаем позицию\n    // сразу, чтобы панель не «мигала» в 0,0 до первого scroll/resize.\n    void update()\n    stopAutoUpdate = autoUpdate(reference, floating, () => void update())\n  }\n\n  watch(\n    open,\n    (isOpen) => {\n      if (!isOpen) {\n        stop()\n        return\n      }\n\n      // `floatingEl` монтируется в том же тике, что и `open` переключается\n      // (v-show уже в DOM, но teleport/переход могут ещё не отработать) —\n      // ждём тик, чтобы `getBoundingClientRect` не читал нулевые размеры.\n      // Перепроверка `open`: панель могли закрыть, пока `start()` ждал в\n      // очереди, — `stop()` уже отработал, и снимать подписку было бы некому.\n      void nextTick(() => {\n        if (open.value) start()\n      })\n    },\n    { immediate: true },\n  )\n\n  onBeforeUnmount(stop)\n\n  return {\n    floatingStyle,\n    resolvedPlacement,\n    update: () => void update(),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAS,eAAe,WAA2B;CACjD,MAAM,SAAS,eAAe;CAE9B,OAAO,SAAS,IAAI,4BAA4B,OAAO,KAAK,OAAO,UAAU;AAC/E;AAEA,SAAS,OAAO,SAA8B;CAC5C,IAAI,OAAO,WAAW,aACpB,OAAO;CAGT,QADY,QAAQ,eAAe,eAAe,OAAA,CACvC,oBAAoB;AACjC;AAEA,SAAS,WAAW,SAAsB,OAAuB;CAC/D,MAAM,MAAM,OAAO,OAAO;CAC1B,OAAO,KAAK,MAAM,QAAQ,GAAG,IAAI;AACnC;;;;;;;;;;;;;;;AAyDA,SAAgB,YACd,aACA,YACA,MACA,UAA8B,CAAC,GACZ;CACnB,MAAM,gBAAgB,IAAmB;EACvC,UAAU;EACV,KAAK;EACL,MAAM;CACR,CAAC;CACD,SAAS,4BAAuC;EAC9C,OAAO,OAAO,QAAQ,cAAc,aAAa,QAAQ,UAAU,IAAI,QAAQ,aAAa;CAC9F;CAEA,SAAS,oBAAqC;EAC5C,OAAO,OAAO,QAAQ,eAAe,aAAa,QAAQ,WAAW,IAAI,QAAQ,cAAc;CACjG;CAEA,MAAM,oBAAoB,IAAe,0BAA0B,CAAC;CAEpE,IAAI,iBAAsC;CAE1C,eAAe,SAAwB;EACrC,MAAM,YAAY,YAAY;EAC9B,MAAM,WAAW,WAAW;EAC5B,IAAI,CAAC,aAAa,CAAC,UACjB;EAEF,MAAM,aAA2B;GAC/B,OAAiB,QAAQ,YAAY,CAAC;GACtC,KAAK,EAAE,SAAS,QAAQ,mBAAmB,EAAE,CAAC;GAC9C,MAAM,EAAE,SAAS,QAAQ,mBAAmB,EAAE,CAAC;EACjD;EAEA,MAAM,aAAa,kBAAkB;EACrC,IAAI,YACF,WAAW,KACT,KAAe,EACb,MAAM,EAAE,OAAO,YAAY;GACzB,IAAI,eAAe,OAAO;IACxB,OAAO,OAAO,SAAS,SAAS,OAAO;KACrC,OAAO;KACP,UAAU,GAAG,MAAM,UAAU,MAAM;IACrC,CAAC;IACD;GACF;GAEA,OAAO,OAAO,SAAS,SAAS,OAAO;IACrC,OAAO,GAAG,MAAM,UAAU,MAAM;IAChC,UAAU;GACZ,CAAC;EACH,EACF,CAAC,CACH;EAGF,MAAM,EAAE,GAAG,GAAG,cAAc,MAAM,gBAAgB,WAAW,UAAU;GACrE,WAAW,0BAA0B;GACrC,UAAU;GACV;EACF,CAAC;EAED,kBAAkB,QAAQ;EAC1B,cAAc,QAAQ;GACpB,UAAU;GACV,MAAM,GAAG,WAAW,UAAU,CAAC,EAAE;GACjC,KAAK,GAAG,WAAW,UAAU,CAAC,EAAE;GAChC,QAAQ,eAAe,QAAQ,aAAa,iBAAiB;EAC/D;CACF;CAEA,SAAS,OAAa;EACpB,iBAAiB;EACjB,iBAAiB;CACnB;CAEA,SAAS,QAAc;EACrB,KAAK;EACL,MAAM,YAAY,YAAY;EAC9B,MAAM,WAAW,WAAW;EAC5B,IAAI,CAAC,aAAa,CAAC,UACjB;EAMF,OAAY;EACZ,iBAAiB,WAAW,WAAW,gBAAgB,KAAK,OAAO,CAAC;CACtE;CAEA,MACE,OACC,WAAW;EACV,IAAI,CAAC,QAAQ;GACX,KAAK;GACL;EACF;EAOA,eAAoB;GAClB,IAAI,KAAK,OAAO,MAAM;EACxB,CAAC;CACH,GACA,EAAE,WAAW,KAAK,CACpB;CAEA,gBAAgB,IAAI;CAEpB,OAAO;EACL;EACA;EACA,cAAc,KAAK,OAAO;CAC5B;AACF"}

package/dist/composables/useFocusTrap.js

@@ -0,0 +1,124 @@
+import { n as getFocusableElementsIn, r as isFocusable } from "../chunks/focusables-BkzK42SQ.js";
+import { nextTick, onScopeDispose, watch } from "vue";
+//#region src/composables/useFocusTrap.ts
+/**
+* Ловушка фокуса: пока активна, Tab ходит по кругу внутри слоя, а фокус,
+* утёкший наружу, возвращается обратно.
+*
+* Реализована на `keydown` и `focusin`, **без sentinel-узлов**: распространённый
+* подход с двумя focus-guard кнопками по краям кладёт в разметку интерактивные
+* элементы, а внутрь контейнера с ARIA-ролью их класть нельзя — роль объявляет
+* потомков презентационными (axe: `nested-interactive`).
+*
+* Слой из ловушки не выводится: порядок окон, Esc и `inert` — забота
+* `useOverlayLayer`. Композиция такая:
+*
+* ```ts
+* const layer = useOverlayLayer(open, close, { modal: true, root: panelRef })
+* useFocusTrap(panelRef, {
+*   active: () => open.value && isTopmost.value,
+*   containers: layer.rootsAbove,
+* })
+* ```
+*/
+function useFocusTrap(container, options = {}) {
+	let previouslyFocused = null;
+	let listening = false;
+	let lastFocusedInside = null;
+	function roots() {
+		const extra = options.containers?.() ?? [];
+		return [container.value, ...extra].filter((root) => Boolean(root));
+	}
+	function contains(target) {
+		if (!target) return false;
+		return roots().some((root) => root === target || root.contains(target));
+	}
+	function focusables() {
+		return getFocusableElementsIn(roots());
+	}
+	function focusInitial() {
+		if (contains(document.activeElement)) return;
+		const requested = options.initialFocus?.();
+		if (requested && isFocusable(requested)) {
+			requested.focus();
+			return;
+		}
+		const [first] = focusables();
+		if (first) {
+			first.focus();
+			return;
+		}
+		(options.fallbackFocus?.() ?? container.value)?.focus();
+	}
+	function onKeydown(event) {
+		if (event.key !== "Tab") return;
+		if (!contains(document.activeElement)) return;
+		const items = focusables();
+		if (items.length === 0) {
+			event.preventDefault();
+			(options.fallbackFocus?.() ?? container.value)?.focus();
+			return;
+		}
+		const first = items[0];
+		const last = items[items.length - 1];
+		const active = document.activeElement;
+		if ((active ? items.indexOf(active) : -1) === -1) {
+			event.preventDefault();
+			(event.shiftKey ? last : first).focus();
+			return;
+		}
+		if (event.shiftKey && active === first) {
+			event.preventDefault();
+			last.focus();
+			return;
+		}
+		if (!event.shiftKey && active === last) {
+			event.preventDefault();
+			first.focus();
+		}
+	}
+	function onFocusIn(event) {
+		const target = event.target;
+		if (contains(target)) {
+			lastFocusedInside = target;
+			return;
+		}
+		if (lastFocusedInside && contains(lastFocusedInside) && isFocusable(lastFocusedInside)) {
+			lastFocusedInside.focus();
+			return;
+		}
+		focusInitial();
+	}
+	function activate() {
+		if (listening) return;
+		if (typeof document === "undefined") return;
+		listening = true;
+		previouslyFocused = document.activeElement ?? null;
+		lastFocusedInside = null;
+		document.addEventListener("keydown", onKeydown, true);
+		document.addEventListener("focusin", onFocusIn, true);
+		nextTick(() => {
+			if (!listening) return;
+			focusInitial();
+		});
+	}
+	function deactivate() {
+		if (!listening) return;
+		listening = false;
+		document.removeEventListener("keydown", onKeydown, true);
+		document.removeEventListener("focusin", onFocusIn, true);
+		const target = previouslyFocused;
+		previouslyFocused = null;
+		lastFocusedInside = null;
+		if (options.restoreFocus === false || !target) return;
+		if (!target.isConnected) return;
+		target.focus?.();
+	}
+	watch(() => Boolean(options.active?.() ?? true) && Boolean(container.value), (isActive) => {
+		if (isActive) activate();
+		else deactivate();
+	}, { immediate: true });
+	onScopeDispose(deactivate);
+}
+//#endregion
+export { useFocusTrap };

package/dist/composables/useFocusTrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusTrap.js","names":[],"sources":["../../src/composables/useFocusTrap.ts"],"sourcesContent":["import type { Ref } from 'vue'\nimport { nextTick, onScopeDispose, watch } from 'vue'\n\nimport { getFocusableElementsIn, isFocusable } from './internal/focusables'\n\nexport interface UseFocusTrapOptions {\n  /**\n   * Работает ли ловушка сейчас. Геттер, а не значение: модальное окно держит\n   * фокус, только пока оно верхнее в стеке слоёв, — иначе нижнее окно отбирало\n   * бы фокус у открытого поверх него.\n   */\n  active?: () => boolean\n  /** Кому отдать фокус при активации. Не задан или не фокусируем — первый в контейнере. */\n  initialFocus?: () => HTMLElement | null | undefined\n  /**\n   * Запасной приёмник фокуса, когда фокусировать внутри нечего: обычно сама\n   * панель с `tabindex=\"-1\"`. Без него фокус остался бы снаружи, и Tab увёл бы\n   * пользователя на страницу под окном.\n   */\n  fallbackFocus?: () => HTMLElement | null | undefined\n  /**\n   * Дополнительные корни, которые считаются частью слоя. Панель селекта,\n   * открытого внутри окна, телепортирована в `body` и лежит вне поддерева\n   * контейнера — без этого списка ловушка отбирала бы у неё фокус.\n   */\n  containers?: () => (HTMLElement | null | undefined)[]\n  /**\n   * Возвращать фокус туда, где он был до активации. По умолчанию — да.\n   * Оверлеи пакета выключают: возврат делает стек слоёв по более строгому\n   * правилу (только если фокус на момент закрытия ещё внутри слоя).\n   */\n  restoreFocus?: boolean\n}\n\n/**\n * Ловушка фокуса: пока активна, Tab ходит по кругу внутри слоя, а фокус,\n * утёкший наружу, возвращается обратно.\n *\n * Реализована на `keydown` и `focusin`, **без sentinel-узлов**: распространённый\n * подход с двумя focus-guard кнопками по краям кладёт в разметку интерактивные\n * элементы, а внутрь контейнера с ARIA-ролью их класть нельзя — роль объявляет\n * потомков презентационными (axe: `nested-interactive`).\n *\n * Слой из ловушки не выводится: порядок окон, Esc и `inert` — забота\n * `useOverlayLayer`. Композиция такая:\n *\n * ```ts\n * const layer = useOverlayLayer(open, close, { modal: true, root: panelRef })\n * useFocusTrap(panelRef, {\n *   active: () => open.value && isTopmost.value,\n *   containers: layer.rootsAbove,\n * })\n * ```\n */\nexport function useFocusTrap(\n  container: Ref<HTMLElement | null>,\n  options: UseFocusTrapOptions = {},\n): void {\n  let previouslyFocused: HTMLElement | null = null\n  let listening = false\n  // Последний законный держатель фокуса: с него начинается возврат, когда\n  // фокус ушёл в никуда (например, кликом по неинтерактивному фону).\n  let lastFocusedInside: HTMLElement | null = null\n\n  function roots(): HTMLElement[] {\n    const extra = options.containers?.() ?? []\n    return [container.value, ...extra].filter((root): root is HTMLElement => Boolean(root))\n  }\n\n  function contains(target: Node | null): boolean {\n    if (!target) return false\n    return roots().some(root => root === target || root.contains(target))\n  }\n\n  function focusables(): HTMLElement[] {\n    return getFocusableElementsIn(roots())\n  }\n\n  function focusInitial(): void {\n    // Фокус уже внутри слоя — его поставили осознанно: диалог наводит на свою\n    // кнопку, окно ввода — на поле, и делают это в тот же такт, когда панель\n    // появилась. `initialFocus` — дефолт слоя, а не приказ, поэтому такую\n    // установку он не перебивает.\n    if (contains(document.activeElement)) return\n\n    const requested = options.initialFocus?.()\n    if (requested && isFocusable(requested)) {\n      requested.focus()\n      return\n    }\n\n    const [first] = focusables()\n    if (first) {\n      first.focus()\n      return\n    }\n\n    // Фокусировать нечего — забираем фокус на сам слой, иначе он останется\n    // снаружи и Tab уведёт пользователя под окно.\n    const fallback = options.fallbackFocus?.() ?? container.value\n    fallback?.focus()\n  }\n\n  function onKeydown(event: KeyboardEvent): void {\n    if (event.key !== 'Tab') return\n    if (!contains(document.activeElement)) return\n\n    const items = focusables()\n    if (items.length === 0) {\n      // Внутри некуда идти — держим фокус на слое, а не отпускаем на страницу.\n      event.preventDefault()\n      ;(options.fallbackFocus?.() ?? container.value)?.focus()\n      return\n    }\n\n    const first = items[0]\n    const last = items[items.length - 1]\n    const active = document.activeElement as HTMLElement | null\n    const index = active ? items.indexOf(active) : -1\n\n    // Фокус на самой панели (`tabindex=\"-1\"`, в списке её нет): Tab обязан\n    // войти внутрь, а не выпрыгнуть за слой.\n    if (index === -1) {\n      event.preventDefault()\n      ;(event.shiftKey ? last : first).focus()\n      return\n    }\n\n    if (event.shiftKey && active === first) {\n      event.preventDefault()\n      last.focus()\n      return\n    }\n\n    if (!event.shiftKey && active === last) {\n      event.preventDefault()\n      first.focus()\n    }\n  }\n\n  function onFocusIn(event: FocusEvent): void {\n    const target = event.target as HTMLElement | null\n\n    if (contains(target)) {\n      lastFocusedInside = target\n      return\n    }\n\n    // Фокус утёк наружу — программным `focus()`, кликом по фону или обходом\n    // через адресную строку. Возвращаем его на последнее законное место.\n    if (lastFocusedInside && contains(lastFocusedInside) && isFocusable(lastFocusedInside)) {\n      lastFocusedInside.focus()\n      return\n    }\n\n    focusInitial()\n  }\n\n  function activate(): void {\n    if (listening) return\n    if (typeof document === 'undefined') return\n    listening = true\n\n    previouslyFocused = (document.activeElement as HTMLElement) ?? null\n    lastFocusedInside = null\n\n    document.addEventListener('keydown', onKeydown, true)\n    document.addEventListener('focusin', onFocusIn, true)\n\n    // Ждём, пока Vue домонтирует содержимое слоя: до этого фокусировать нечего.\n    void nextTick(() => {\n      if (!listening) return\n      focusInitial()\n    })\n  }\n\n  function deactivate(): void {\n    if (!listening) return\n    listening = false\n\n    document.removeEventListener('keydown', onKeydown, true)\n    document.removeEventListener('focusin', onFocusIn, true)\n\n    const target = previouslyFocused\n    previouslyFocused = null\n    lastFocusedInside = null\n\n    if (options.restoreFocus === false || !target) return\n    if (!target.isConnected) return\n    target.focus?.()\n  }\n\n  watch(\n    () => Boolean(options.active?.() ?? true) && Boolean(container.value),\n    (isActive) => {\n      if (isActive) activate()\n      else deactivate()\n    },\n    { immediate: true },\n  )\n\n  onScopeDispose(deactivate)\n}\n"],"mappings":"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"}

package/dist/composables/useGrComponentConfig.js

@@ -0,0 +1,2 @@
+import { a as useGrComponentProp, c as useGrThemeAttrs, i as useGrComponentDefaults, o as useGrComponentSize, r as resolveGrConfig, s as useGrConfig } from "../chunks/context-BSYR7RZs.js";
+export { resolveGrConfig, useGrComponentDefaults, useGrComponentProp, useGrComponentSize, useGrConfig, useGrThemeAttrs };

package/dist/composables/useGrFormControl.js

@@ -0,0 +1,24 @@
+import { n as useGrFormFieldContext } from "../chunks/context-DdNIxa1w.js";
+import { computed } from "vue";
+//#region src/composables/useGrFormControl.ts
+/**
+* @param source геттер собственных пропов контрола. Геттер, а не объект, —
+* чтобы не терять реактивность на `props`.
+*/
+function useGrFormControl(source = () => ({})) {
+	const field = useGrFormFieldContext();
+	const disabled = computed(() => Boolean(source().disabled) || Boolean(field?.disabled.value));
+	const readonly = computed(() => Boolean(source().readonly) || Boolean(field?.readonly.value));
+	return {
+		disabled,
+		readonly,
+		invalid: computed(() => Boolean(source().invalid) || Boolean(field?.invalid.value)),
+		required: computed(() => Boolean(source().required) || Boolean(field?.required.value)),
+		id: computed(() => field?.id.value),
+		labelId: computed(() => field?.labelId.value),
+		describedBy: computed(() => field?.describedById.value),
+		locked: computed(() => disabled.value || readonly.value)
+	};
+}
+//#endregion
+export { useGrFormControl };

package/dist/composables/useGrFormControl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGrFormControl.js","names":[],"sources":["../../src/composables/useGrFormControl.ts"],"sourcesContent":["import type { ComputedRef } from 'vue'\nimport { computed } from 'vue'\n\nimport { useGrFormFieldContext } from '../components/GrFormField/context'\n\n/**\n * Общий контракт форм-контрола.\n *\n * До него каждый контрол решал одно и то же по-своему: `invalid` был то своим\n * пропом, то только контекстом, то не был реализован вовсе; `readonly` жил у\n * трёх контролов из пятнадцати, `required` — у двух. Из-за этого «форма только\n * на чтение» приходилось делать через `disabled`, а это меняет и семантику\n * (значение не уходит в форму), и контраст.\n *\n * Композабл сводит два источника — собственные пропы контрола и контекст\n * `GrFormField` — в одно состояние. Правило одно: **проп контрола сильнее**,\n * контекст работает как fallback. Исключение — `invalid`, `required` и\n * `disabled`: там источники складываются по «или», потому что поле может\n * объявить ошибку, о которой контрол не знает (правило формы), а форма —\n * выключить себя целиком на время отправки.\n */\n\nexport interface GrFormControlProps {\n  /** Контрол недоступен: не фокусируется, значение не отправляется. */\n  disabled?: boolean\n  /** Значение видно и отправляется, но не редактируется. */\n  readonly?: boolean\n  /** Визуальное и ARIA-состояние ошибки. */\n  invalid?: boolean\n  /** Обязательное поле. */\n  required?: boolean\n  /** Доступное имя вне `GrFormField`. */\n  ariaLabel?: string\n}\n\nexport interface GrFormControlState {\n  /** Итоговый `disabled`. */\n  disabled: ComputedRef<boolean>\n  /** Итоговый `readonly`. */\n  readonly: ComputedRef<boolean>\n  /** Итоговый `invalid`: свой проп ИЛИ ошибка поля. */\n  invalid: ComputedRef<boolean>\n  /** Итоговый `required`: свой проп ИЛИ обязательность поля. */\n  required: ComputedRef<boolean>\n  /** Id контрола из поля (для `<label for>`). */\n  id: ComputedRef<string | undefined>\n  /** Id подписи поля — для виджетов с ARIA-ролью, к которым `<label for>` неприменим. */\n  labelId: ComputedRef<string | undefined>\n  /** `aria-describedby`: подсказка и/или текст ошибки поля. */\n  describedBy: ComputedRef<string | undefined>\n  /** `true`, когда контрол не принимает ввод (`disabled` или `readonly`). */\n  locked: ComputedRef<boolean>\n}\n\n/**\n * @param source геттер собственных пропов контрола. Геттер, а не объект, —\n * чтобы не терять реактивность на `props`.\n */\nexport function useGrFormControl(source: () => GrFormControlProps = () => ({})): GrFormControlState {\n  const field = useGrFormFieldContext()\n\n  // Везде «или», а не `??`: у контролов эти пропы объявлены с дефолтом `false`,\n  // и `??` до контекста просто не доходил бы — поле не смогло бы включить\n  // `readonly` контролу, у которого свой проп не выставлен.\n  const disabled = computed(() => Boolean(source().disabled) || Boolean(field?.disabled.value))\n  const readonly = computed(() => Boolean(source().readonly) || Boolean(field?.readonly.value))\n  const invalid = computed(() => Boolean(source().invalid) || Boolean(field?.invalid.value))\n  const required = computed(() => Boolean(source().required) || Boolean(field?.required.value))\n\n  return {\n    disabled,\n    readonly,\n    invalid,\n    required,\n    id: computed(() => field?.id.value),\n    labelId: computed(() => field?.labelId.value),\n    describedBy: computed(() => field?.describedById.value),\n    locked: computed(() => disabled.value || readonly.value),\n  }\n}\n"],"mappings":";;;;;;;AA0DA,SAAgB,iBAAiB,gBAA0C,CAAC,IAAwB;CAClG,MAAM,QAAQ,sBAAsB;CAKpC,MAAM,WAAW,eAAe,QAAQ,OAAO,CAAC,CAAC,QAAQ,KAAK,QAAQ,OAAO,SAAS,KAAK,CAAC;CAC5F,MAAM,WAAW,eAAe,QAAQ,OAAO,CAAC,CAAC,QAAQ,KAAK,QAAQ,OAAO,SAAS,KAAK,CAAC;CAI5F,OAAO;EACL;EACA;EACA,SANc,eAAe,QAAQ,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ,OAAO,QAAQ,KAAK,CAMtF;EACA,UANe,eAAe,QAAQ,OAAO,CAAC,CAAC,QAAQ,KAAK,QAAQ,OAAO,SAAS,KAAK,CAMzF;EACA,IAAI,eAAe,OAAO,GAAG,KAAK;EAClC,SAAS,eAAe,OAAO,QAAQ,KAAK;EAC5C,aAAa,eAAe,OAAO,cAAc,KAAK;EACtD,QAAQ,eAAe,SAAS,SAAS,SAAS,KAAK;CACzD;AACF"}

package/dist/composables/useGranularityTranslations.js

@@ -0,0 +1,2 @@
+import { n as useGranularityTranslations } from "../chunks/granularityI18n-BC5zsj_d.js";
+export { useGranularityTranslations };

package/dist/composables/useOverlayLayer.js

@@ -0,0 +1,65 @@
+import { i as removeOverlayLayer, r as pushOverlayLayer, t as layerRootsAbove } from "../chunks/overlayStack-C8cfsqXa.js";
+import { nextTick, onUnmounted, watch } from "vue";
+//#region src/composables/useOverlayLayer.ts
+/**
+* Регистрирует оверлей в общем стеке слоёв, пока `open` истинно.
+*
+* Один контракт на порядок Esc, `inert` и возврат фокуса — три механизма,
+* которые обязаны видеть один и тот же порядок слоёв. Что берёт на себя:
+*
+*  - **Esc** — верхнему слою, вниз не проваливается;
+*  - **`inert`** — через `onTopmostChange` у модальных слоёв;
+*  - **возврат фокуса** — по единому правилу (см. ниже).
+*
+* Чего **не** делает: фокус-ловушку — это `useFocusTrap`, отдельный примитив.
+* Поповеру ловушка и не нужна: Tab обязан уводить фокус наружу и закрывать его,
+* поэтому связка «слой + ловушка» собирается в компоненте, а не тут.
+*
+* Правило возврата фокуса: восстанавливаем, **только если на момент закрытия
+* фокус всё ещё внутри слоя**. Если пользователь кликнул в другое поле, фокус
+* уже там — забирать его обратно нельзя. Эвристика «возвращать, если открыли с
+* клавиатуры» промахивается в обе стороны: мышью открытый слой фокус не вернёт,
+* а клавиатурный отберёт его у того, куда пользователь ушёл сам.
+*/
+function useOverlayLayer(open, onDismiss, options = {}) {
+	let layerId = null;
+	let previouslyFocused = null;
+	function register() {
+		if (layerId !== null) return;
+		if (typeof window === "undefined") return;
+		if (options.restoreFocus !== false && typeof document !== "undefined") previouslyFocused = document.activeElement ?? null;
+		layerId = pushOverlayLayer({
+			modal: typeof options.modal === "function" ? options.modal() : options.modal ?? false,
+			shouldClose: () => options.closeOnEscape?.() ?? true,
+			close: onDismiss,
+			setTopmost: options.onTopmostChange,
+			root: () => options.root?.value ?? null
+		});
+	}
+	function unregister() {
+		if (layerId === null) return;
+		removeOverlayLayer(layerId);
+		layerId = null;
+		restoreFocus();
+	}
+	function restoreFocus() {
+		const target = previouslyFocused;
+		previouslyFocused = null;
+		if (options.restoreFocus === false || !target) return;
+		if (typeof document === "undefined") return;
+		const active = document.activeElement;
+		const root = options.root?.value;
+		if (root && active && active !== document.body && !root.contains(active)) return;
+		nextTick(() => {
+			if (target.isConnected) target.focus?.();
+		});
+	}
+	watch(open, (isOpen) => {
+		if (isOpen) register();
+		else unregister();
+	}, { immediate: true });
+	onUnmounted(unregister);
+	return { rootsAbove: () => layerId === null ? [] : layerRootsAbove(layerId) };
+}
+//#endregion
+export { useOverlayLayer };

package/dist/composables/useOverlayLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOverlayLayer.js","names":[],"sources":["../../src/composables/useOverlayLayer.ts"],"sourcesContent":["import type { Ref } from 'vue'\nimport { nextTick, onUnmounted, watch } from 'vue'\n\nimport { layerRootsAbove, pushOverlayLayer, removeOverlayLayer } from './internal/overlayStack'\n\nexport interface UseOverlayLayerOptions {\n  /**\n   * Модальный слой: блокирует страницу, и модалки под ним получают `inert`.\n   * Немодальные (поповеры, меню, подсказки) участвуют только в очереди Esc.\n   * По умолчанию `false`.\n   *\n   * Геттером — там, где модальность включается пропом (`GrDrawer`): значение\n   * читается в момент регистрации, то есть при каждом открытии.\n   */\n  modal?: boolean | (() => boolean)\n  /**\n   * Закрывать ли слой по Esc. Геттер, а не значение, — чтобы читать реактивный\n   * проп (`closeOnEsc`). По умолчанию закрывается всегда.\n   *\n   * Если геттер вернёт `false`, нажатие всё равно не пройдёт на слой ниже:\n   * пользователь видит верхним этот слой, и Esc адресован ему.\n   */\n  closeOnEscape?: () => boolean\n  /**\n   * Уведомление «этот модальный слой сейчас верхний». Компонент вешает по нему\n   * `inert` на свой корень, когда перестал быть верхним.\n   */\n  onTopmostChange?: (isTopmost: boolean) => void\n  /**\n   * Возвращать фокус элементу, который был активен до открытия. По умолчанию —\n   * да. Отключать имеет смысл там, где фокус с триггера и не уходил: `GrSelect`\n   * ведёт список через `aria-activedescendant`.\n   */\n  restoreFocus?: boolean\n  /**\n   * Корень слоя. Нужен дважды: для правила возврата фокуса (если на момент\n   * закрытия фокус уже вне слоя, пользователь ушёл сам — забирать нельзя) и\n   * для ловушки фокуса слоя под ним, которая обязана считать этот корень\n   * своим (панель селекта внутри модалки телепортирована в `body`).\n   */\n  root?: Ref<HTMLElement | null>\n}\n\nexport interface OverlayLayerHandle {\n  /**\n   * Корни слоёв, открытых поверх этого. Передаётся в `useFocusTrap` как\n   * `containers`: пока панель, открытая изнутри окна, жива, фокус в ней\n   * законен.\n   */\n  rootsAbove: () => HTMLElement[]\n}\n\n/**\n * Регистрирует оверлей в общем стеке слоёв, пока `open` истинно.\n *\n * Один контракт на порядок Esc, `inert` и возврат фокуса — три механизма,\n * которые обязаны видеть один и тот же порядок слоёв. Что берёт на себя:\n *\n *  - **Esc** — верхнему слою, вниз не проваливается;\n *  - **`inert`** — через `onTopmostChange` у модальных слоёв;\n *  - **возврат фокуса** — по единому правилу (см. ниже).\n *\n * Чего **не** делает: фокус-ловушку — это `useFocusTrap`, отдельный примитив.\n * Поповеру ловушка и не нужна: Tab обязан уводить фокус наружу и закрывать его,\n * поэтому связка «слой + ловушка» собирается в компоненте, а не тут.\n *\n * Правило возврата фокуса: восстанавливаем, **только если на момент закрытия\n * фокус всё ещё внутри слоя**. Если пользователь кликнул в другое поле, фокус\n * уже там — забирать его обратно нельзя. Эвристика «возвращать, если открыли с\n * клавиатуры» промахивается в обе стороны: мышью открытый слой фокус не вернёт,\n * а клавиатурный отберёт его у того, куда пользователь ушёл сам.\n */\nexport function useOverlayLayer(\n  open: Ref<boolean>,\n  onDismiss: () => void,\n  options: UseOverlayLayerOptions = {},\n): OverlayLayerHandle {\n  let layerId: number | null = null\n  let previouslyFocused: HTMLElement | null = null\n\n  function register(): void {\n    if (layerId !== null) return\n\n    // Стек — браузерное понятие: Esc, `inert` и возврат фокуса на сервере\n    // бессмысленны. Регистрируйся слой и там — он остался бы в модульном массиве\n    // навсегда, потому что `onUnmounted` при `renderToString` не вызывается, и\n    // каждый серверный рендер открытого оверлея копил бы замыкание со ссылками\n    // на свои компоненты.\n    if (typeof window === 'undefined') return\n\n    if (options.restoreFocus !== false && typeof document !== 'undefined')\n      previouslyFocused = (document.activeElement as HTMLElement) ?? null\n\n    layerId = pushOverlayLayer({\n      modal: typeof options.modal === 'function' ? options.modal() : options.modal ?? false,\n      shouldClose: () => options.closeOnEscape?.() ?? true,\n      close: onDismiss,\n      setTopmost: options.onTopmostChange,\n      root: () => options.root?.value ?? null,\n    })\n  }\n\n  function unregister(): void {\n    if (layerId === null) return\n    removeOverlayLayer(layerId)\n    layerId = null\n\n    restoreFocus()\n  }\n\n  function restoreFocus(): void {\n    const target = previouslyFocused\n    previouslyFocused = null\n\n    if (options.restoreFocus === false || !target) return\n    if (typeof document === 'undefined') return\n\n    // Фокус уже вне слоя — пользователь ушёл сам, отбирать нельзя. Решение\n    // принимаем сейчас, пока слой ещё в DOM, а применяем следующим тиком.\n    const active = document.activeElement\n    const root = options.root?.value\n    if (root && active && active !== document.body && !root.contains(active)) return\n\n    // Возврат откладывается намеренно: ловушка фокуса того же слоя снимает свои\n    // слушатели в этом же флаше, и сфокусируй мы триггер сразу — она затащила бы\n    // фокус обратно в закрывающийся слой.\n    void nextTick(() => {\n      if (target.isConnected) target.focus?.()\n    })\n  }\n\n  watch(\n    open,\n    (isOpen) => {\n      if (isOpen) register()\n      else unregister()\n    },\n    { immediate: true },\n  )\n\n  onUnmounted(unregister)\n\n  return {\n    rootsAbove: () => (layerId === null ? [] : layerRootsAbove(layerId)),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwEA,SAAgB,gBACd,MACA,WACA,UAAkC,CAAC,GACf;CACpB,IAAI,UAAyB;CAC7B,IAAI,oBAAwC;CAE5C,SAAS,WAAiB;EACxB,IAAI,YAAY,MAAM;EAOtB,IAAI,OAAO,WAAW,aAAa;EAEnC,IAAI,QAAQ,iBAAiB,SAAS,OAAO,aAAa,aACxD,oBAAqB,SAAS,iBAAiC;EAEjE,UAAU,iBAAiB;GACzB,OAAO,OAAO,QAAQ,UAAU,aAAa,QAAQ,MAAM,IAAI,QAAQ,SAAS;GAChF,mBAAmB,QAAQ,gBAAgB,KAAK;GAChD,OAAO;GACP,YAAY,QAAQ;GACpB,YAAY,QAAQ,MAAM,SAAS;EACrC,CAAC;CACH;CAEA,SAAS,aAAmB;EAC1B,IAAI,YAAY,MAAM;EACtB,mBAAmB,OAAO;EAC1B,UAAU;EAEV,aAAa;CACf;CAEA,SAAS,eAAqB;EAC5B,MAAM,SAAS;EACf,oBAAoB;EAEpB,IAAI,QAAQ,iBAAiB,SAAS,CAAC,QAAQ;EAC/C,IAAI,OAAO,aAAa,aAAa;EAIrC,MAAM,SAAS,SAAS;EACxB,MAAM,OAAO,QAAQ,MAAM;EAC3B,IAAI,QAAQ,UAAU,WAAW,SAAS,QAAQ,CAAC,KAAK,SAAS,MAAM,GAAG;EAK1E,eAAoB;GAClB,IAAI,OAAO,aAAa,OAAO,QAAQ;EACzC,CAAC;CACH;CAEA,MACE,OACC,WAAW;EACV,IAAI,QAAQ,SAAS;OAChB,WAAW;CAClB,GACA,EAAE,WAAW,KAAK,CACpB;CAEA,YAAY,UAAU;CAEtB,OAAO,EACL,kBAAmB,YAAY,OAAO,CAAC,IAAI,gBAAgB,OAAO,EACpE;AACF"}

package/dist/composables/usePortalTarget.js

@@ -0,0 +1,2 @@
+import { t as usePortalTarget } from "../chunks/usePortalTarget-RyzEgNTb.js";
+export { usePortalTarget };

package/dist/composables/useRovingFocus.js

@@ -0,0 +1,150 @@
+import { computed, ref } from "vue";
+//#region src/composables/useRovingFocus.ts
+function useRovingFocus(options) {
+	const activeKey = ref();
+	const orientation = () => options.orientation?.() ?? "vertical";
+	const wraps = () => options.wrap?.() ?? true;
+	const skips = () => options.skipDisabled?.() ?? false;
+	const disabled = (key) => options.isDisabled?.(key) ?? false;
+	function firstFocusable(items) {
+		if (!skips()) return items[0];
+		return items.find((key) => !disabled(key)) ?? items[0];
+	}
+	/**
+	* Роверный элемент. Порядок: явно активный (если ещё в наборе) → стартовый →
+	* первый доступный. Именно здесь живёт инвариант «ровно один `tabindex=0`»:
+	* пока набор непуст, ответ не бывает пустым.
+	*/
+	const rovingKey = computed(() => {
+		const items = options.items();
+		if (items.length === 0) return void 0;
+		const active = activeKey.value;
+		if (active !== void 0 && items.includes(active)) return active;
+		const initial = options.initialKey?.();
+		if (initial !== void 0 && items.includes(initial)) return initial;
+		return firstFocusable(items);
+	});
+	function tabindexFor(key) {
+		return rovingKey.value === key ? 0 : -1;
+	}
+	function setActive(key) {
+		activeKey.value = key;
+	}
+	function reset() {
+		activeKey.value = void 0;
+	}
+	function focusKey(key) {
+		const previous = rovingKey.value;
+		activeKey.value = key;
+		if (key !== previous) options.onMove?.(key, previous);
+		const focusNow = () => {
+			options.elementFor(key)?.focus();
+		};
+		const pending = options.beforeFocus?.(key);
+		if (pending && typeof pending.then === "function") return pending.then(focusNow);
+		focusNow();
+		return Promise.resolve();
+	}
+	/**
+	* Индекс цели после сдвига. `undefined` — движение невозможно: упёрлись в
+	* край без зацикливания либо весь набор выключен.
+	*/
+	function targetIndex(from, delta) {
+		const items = options.items();
+		const len = items.length;
+		if (len === 0 || delta === 0) return void 0;
+		let index = from;
+		for (let attempt = 0; attempt < len; attempt += 1) {
+			const next = index + delta;
+			if (next < 0 || next >= len) {
+				if (!wraps()) return void 0;
+				index = (next % len + len) % len;
+			} else index = next;
+			if (!skips() || !disabled(items[index])) return index;
+		}
+	}
+	function currentIndex() {
+		const items = options.items();
+		const key = rovingKey.value;
+		return key === void 0 ? -1 : items.indexOf(key);
+	}
+	function moveBy(delta) {
+		const items = options.items();
+		const from = currentIndex();
+		if (from < 0) return false;
+		const target = targetIndex(from, delta);
+		if (target === void 0) {
+			const edge = delta > 0 ? "end" : "start";
+			return options.onOverflow?.(edge, delta) ?? false;
+		}
+		focusKey(items[target]);
+		return true;
+	}
+	function rowBounds(index) {
+		const len = options.items().length;
+		const width = Math.max(1, options.columns?.() ?? len);
+		const row = Math.floor(index / width);
+		return [row * width, Math.min(row * width + width - 1, len - 1)];
+	}
+	function moveToEdge(edge) {
+		const items = options.items();
+		if (items.length === 0) return false;
+		const from = currentIndex();
+		const [start, end] = orientation() === "grid" && from >= 0 ? rowBounds(from) : [0, items.length - 1];
+		const target = edge === "start" ? start : end;
+		if (!skips()) {
+			focusKey(items[target]);
+			return true;
+		}
+		const direction = edge === "start" ? 1 : -1;
+		for (let index = target; index >= start && index <= end; index += direction) {
+			const key = items[index];
+			if (!disabled(key)) {
+				focusKey(key);
+				return true;
+			}
+		}
+		return false;
+	}
+	/** Шаг вперёд/назад по объявленной ориентации; `0` — клавиша этой оси не касается. */
+	function deltaForKey(key) {
+		const mode = orientation();
+		const columns = Math.max(1, options.columns?.() ?? 1);
+		switch (key) {
+			case "ArrowRight": return mode === "vertical" ? 0 : 1;
+			case "ArrowLeft": return mode === "vertical" ? 0 : -1;
+			case "ArrowDown":
+				if (mode === "horizontal") return 0;
+				return mode === "grid" ? columns : 1;
+			case "ArrowUp":
+				if (mode === "horizontal") return 0;
+				return mode === "grid" ? -columns : -1;
+			default: return 0;
+		}
+	}
+	function handleNavigationKeys(event) {
+		if (event.altKey || event.ctrlKey || event.metaKey) return false;
+		if (event.key === "Home" || event.key === "End") {
+			const moved = moveToEdge(event.key === "Home" ? "start" : "end");
+			if (moved) event.preventDefault();
+			return moved;
+		}
+		const delta = deltaForKey(event.key);
+		if (delta === 0) return false;
+		const moved = moveBy(delta);
+		if (moved) event.preventDefault();
+		return moved;
+	}
+	return {
+		rovingKey,
+		tabindexFor,
+		setActive,
+		reset,
+		focusKey,
+		moveBy,
+		moveToEdge,
+		handleNavigationKeys
+	};
+}
+//#endregion
+export { useRovingFocus };

package/dist/composables/useRovingFocus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRovingFocus.js","names":[],"sources":["../../src/composables/useRovingFocus.ts"],"sourcesContent":["import type { ComputedRef, Ref } from 'vue'\nimport { computed, ref } from 'vue'\n\n/**\n * Roving tabindex: группа — одна остановка `Tab`, внутрь заходят стрелками.\n *\n * Механика написана в пакете шесть раз (`GrDropdownMenu`, `GrTree`, `GrTabs`,\n * `GrSegmented`, `GrRadio`, `GrInputTag`) и разошлась не стилистически, а по\n * существу: у одних кольцо зациклено, у других упирается в края; одни\n * пропускают выключенные элементы, другие намеренно нет; адресуются то\n * индексом, то ключом, то значением. Каждое расхождение здесь стало опцией —\n * поэтому опций много, и это дешевле, чем седьмая копия.\n *\n * Осознанно **не** обобщается активация: `Enter`/`Space` и «двигает ли стрелка\n * выбор» — доменная логика компонента. У `GrSegmented` и `GrRadio` стрелка\n * меняет значение, у `GrTree` и `GrInputTag` — нет, у `GrTabs` это проп.\n * Примитив ведёт фокус и отдаёт `onMove`; что делать с переездом, решает\n * компонент.\n *\n * Инвариант «ровно один элемент с `tabindex=\"0\"`» держит `rovingKey`: это\n * `computed`, а не `ref`, поэтому при смене набора он самокорректируется в\n * момент чтения. Отдельная нормализация с `watch(..., { flush: 'sync' })`,\n * как в `GrTree`, больше не нужна.\n */\n\n/** Какие стрелки ведут по набору. */\nexport type GrRovingOrientation = 'horizontal' | 'vertical' | 'both' | 'grid'\n\n/** Край набора, в который упёрлось движение. */\nexport type GrRovingEdge = 'start' | 'end'\n\nexport interface UseRovingFocusOptions<TKey> {\n  /** Ключи элементов в порядке отображения. Индекс, значение, opaque-ключ — что угодно сравнимое по `===`. */\n  items: () => readonly TKey[]\n  /**\n   * DOM-узел элемента. Массив ref-ов, `Map`, `querySelector` — примитиву\n   * безразлично, знать раскладку обязан компонент.\n   */\n  elementFor: (key: TKey) => HTMLElement | null | undefined\n  /** Выключен ли элемент. Спрашивается только при `skipDisabled`. */\n  isDisabled?: (key: TKey) => boolean\n  /** По умолчанию `vertical`. */\n  orientation?: () => GrRovingOrientation\n  /** Ширина строки для `orientation: 'grid'`. Игнорируется в остальных режимах. */\n  columns?: () => number\n  /** Замкнуто ли кольцо. По умолчанию `true`. */\n  wrap?: () => boolean\n  /**\n   * Пропускать выключенные при движении. По умолчанию `false`: в паттерне\n   * `menu` выключенный пункт остаётся в обходе намеренно — `aria-disabled`\n   * оставляет его фокусируемым, чтобы скринридер прочёл, что он есть.\n   */\n  skipDisabled?: () => boolean\n  /**\n   * Стартовый элемент, когда фокус в группе ещё не был — обычно выбранное\n   * значение.\n   *\n   * **Выключенность здесь не проверяется, и это не упущение.** Проверить её\n   * автоматически по `isDisabled` нельзя: у `GrSegmented` загружающийся сегмент\n   * остановку `Tab` сохраняет, хотя для движения заблокирован, а у `GrRadio`\n   * выключенный переключатель терять её обязан. Условие знает только вызывающий,\n   * поэтому геттер обязан вернуть `undefined` для значения, которое не может\n   * принять фокус. Забыть об этом — значит оставить группу без остановки `Tab`\n   * вовсе: элемент с `tabindex=\"0\"` будет назначен, но отрисует `-1`.\n   */\n  initialKey?: () => TKey | undefined\n  /**\n   * Позиция переехала — компонент решает, менять ли заодно выбор. Вызывается\n   * **до** переноса фокуса: в `radiogroup` стрелка переносит выбор, и модель\n   * обязана примениться раньше, чем сфокусируется целевой элемент.\n   */\n  onMove?: (key: TKey, previous: TKey | undefined) => void\n  /**\n   * Движение упёрлось в край при `wrap: false`. Вернул `true` — считаем клавишу\n   * обработанной (кольцо `GrInputTag` так отдаёт фокус полю ввода, календарь —\n   * листает месяц).\n   */\n  onOverflow?: (edge: GrRovingEdge, delta: number) => boolean\n  /**\n   * Донести элемент до экрана перед фокусом: виртуализация, `scrollIntoView`,\n   * ожидание перерисовки после `onMove`. Вернул промис — фокус ждёт ровно его,\n   * без добавленных примитивом тиков; вернул `undefined` — фокус остаётся\n   * синхронным, чтобы не менять тайминг у компонентов, которые на него\n   * полагаются.\n   */\n  beforeFocus?: (key: TKey) => void | Promise<void>\n}\n\nexport interface UseRovingFocusReturn<TKey> {\n  /** Элемент, который держит `tabindex=\"0\"`. Никогда не «никто» при непустом наборе. */\n  rovingKey: ComputedRef<TKey | undefined>\n  /** `0` для роверного элемента, `-1` для всех остальных. */\n  tabindexFor: (key: TKey) => 0 | -1\n  /** Сделать активным без переноса фокуса — для синхронизации с мышью (`@focus`, `@click`). */\n  setActive: (key: TKey) => void\n  /**\n   * Забыть явно наведённый фокус: остановка `Tab` возвращается к производной\n   * (`initialKey` → первый доступный). Нужно, когда набор опустел, — иначе\n   * устаревший ключ всплывёт, как только элементы появятся снова.\n   */\n  reset: () => void\n  /** Сделать активным и перенести фокус. */\n  focusKey: (key: TKey) => Promise<void>\n  /** Сдвиг на `delta` позиций от текущего. Вернёт `false`, если движение не состоялось. */\n  moveBy: (delta: number) => boolean\n  /** На край набора (в `grid` — на край текущей строки). */\n  moveToEdge: (edge: GrRovingEdge) => boolean\n  /**\n   * Стрелки, `Home`, `End` по объявленной ориентации. Возвращает `true`, если\n   * клавиша обработана (с `preventDefault`) — остальное компонент разбирает сам.\n   */\n  handleNavigationKeys: (event: KeyboardEvent) => boolean\n}\n\nexport function useRovingFocus<TKey>(\n  options: UseRovingFocusOptions<TKey>,\n): UseRovingFocusReturn<TKey> {\n  const activeKey: Ref<TKey | undefined> = ref()\n\n  const orientation = (): GrRovingOrientation => options.orientation?.() ?? 'vertical'\n  const wraps = (): boolean => options.wrap?.() ?? true\n  const skips = (): boolean => options.skipDisabled?.() ?? false\n  const disabled = (key: TKey): boolean => options.isDisabled?.(key) ?? false\n\n  function firstFocusable(items: readonly TKey[]): TKey | undefined {\n    if (!skips()) return items[0]\n    return items.find(key => !disabled(key)) ?? items[0]\n  }\n\n  /**\n   * Роверный элемент. Порядок: явно активный (если ещё в наборе) → стартовый →\n   * первый доступный. Именно здесь живёт инвариант «ровно один `tabindex=0`»:\n   * пока набор непуст, ответ не бывает пустым.\n   */\n  const rovingKey = computed<TKey | undefined>(() => {\n    const items = options.items()\n    if (items.length === 0) return undefined\n\n    const active = activeKey.value\n    if (active !== undefined && items.includes(active)) return active\n\n    const initial = options.initialKey?.()\n    if (initial !== undefined && items.includes(initial)) return initial\n\n    return firstFocusable(items)\n  })\n\n  function tabindexFor(key: TKey): 0 | -1 {\n    return rovingKey.value === key ? 0 : -1\n  }\n\n  function setActive(key: TKey): void {\n    activeKey.value = key\n  }\n\n  function reset(): void {\n    activeKey.value = undefined\n  }\n\n  function focusKey(key: TKey): Promise<void> {\n    const previous = rovingKey.value\n    activeKey.value = key\n\n    // Состояние — до фокуса: `onMove` часто меняет модель (в `radiogroup`\n    // стрелка переносит выбор), и компонент вправе рассчитывать, что к моменту\n    // фокуса оно уже применено.\n    if (key !== previous) options.onMove?.(key, previous)\n\n    const focusNow = (): void => {\n      options.elementFor(key)?.focus()\n    }\n\n    const pending = options.beforeFocus?.(key)\n    if (pending && typeof pending.then === 'function') {\n      return pending.then(focusNow)\n    }\n\n    focusNow()\n    return Promise.resolve()\n  }\n\n  /**\n   * Индекс цели после сдвига. `undefined` — движение невозможно: упёрлись в\n   * край без зацикливания либо весь набор выключен.\n   */\n  function targetIndex(from: number, delta: number): number | undefined {\n    const items = options.items()\n    const len = items.length\n    if (len === 0 || delta === 0) return undefined\n\n    let index = from\n\n    // Шагов не больше размера набора: полный оборот без единого доступного\n    // элемента означает, что двигаться некуда. Шаг на каждой итерации тот же —\n    // выключенный элемент в сетке перешагивается по вертикали, сохраняя\n    // колонку; прыжок «вбок» был бы неожиданным.\n    for (let attempt = 0; attempt < len; attempt += 1) {\n      const next = index + delta\n\n      if (next < 0 || next >= len) {\n        if (!wraps()) return undefined\n        // Зацикливание по модулю набора. Колонку это сохраняет, когда длина\n        // кратна ширине строки — у календарной сетки 42 = 6 × 7 так и есть.\n        index = ((next % len) + len) % len\n      }\n      else {\n        index = next\n      }\n\n      if (!skips() || !disabled(items[index])) return index\n    }\n\n    return undefined\n  }\n\n  function currentIndex(): number {\n    const items = options.items()\n    const key = rovingKey.value\n    return key === undefined ? -1 : items.indexOf(key)\n  }\n\n  function moveBy(delta: number): boolean {\n    const items = options.items()\n    // `rovingKey` пуст только при пустом наборе — двигаться нечем.\n    const from = currentIndex()\n    if (from < 0) return false\n\n    const target = targetIndex(from, delta)\n    if (target === undefined) {\n      const edge: GrRovingEdge = delta > 0 ? 'end' : 'start'\n      return options.onOverflow?.(edge, delta) ?? false\n    }\n\n    void focusKey(items[target])\n    return true\n  }\n\n  function rowBounds(index: number): [number, number] {\n    const len = options.items().length\n    const width = Math.max(1, options.columns?.() ?? len)\n    const row = Math.floor(index / width)\n    return [row * width, Math.min(row * width + width - 1, len - 1)]\n  }\n\n  function moveToEdge(edge: GrRovingEdge): boolean {\n    const items = options.items()\n    if (items.length === 0) return false\n\n    const from = currentIndex()\n    // В сетке `Home`/`End` — края строки (в календаре это начало и конец\n    // недели); в линейных режимах — края всего набора.\n    const [start, end] = orientation() === 'grid' && from >= 0\n      ? rowBounds(from)\n      : [0, items.length - 1]\n\n    const target = edge === 'start' ? start : end\n    if (!skips()) {\n      void focusKey(items[target])\n      return true\n    }\n\n    const direction = edge === 'start' ? 1 : -1\n    for (let index = target; index >= start && index <= end; index += direction) {\n      const key = items[index]\n      if (!disabled(key)) {\n        void focusKey(key)\n        return true\n      }\n    }\n    return false\n  }\n\n  /** Шаг вперёд/назад по объявленной ориентации; `0` — клавиша этой оси не касается. */\n  function deltaForKey(key: string): number {\n    const mode = orientation()\n    const columns = Math.max(1, options.columns?.() ?? 1)\n\n    switch (key) {\n      case 'ArrowRight':\n        return mode === 'vertical' ? 0 : 1\n      case 'ArrowLeft':\n        return mode === 'vertical' ? 0 : -1\n      case 'ArrowDown':\n        if (mode === 'horizontal') return 0\n        return mode === 'grid' ? columns : 1\n      case 'ArrowUp':\n        if (mode === 'horizontal') return 0\n        return mode === 'grid' ? -columns : -1\n      default:\n        return 0\n    }\n  }\n\n  function handleNavigationKeys(event: KeyboardEvent): boolean {\n    if (event.altKey || event.ctrlKey || event.metaKey) return false\n\n    if (event.key === 'Home' || event.key === 'End') {\n      const moved = moveToEdge(event.key === 'Home' ? 'start' : 'end')\n      if (moved) event.preventDefault()\n      return moved\n    }\n\n    const delta = deltaForKey(event.key)\n    if (delta === 0) return false\n\n    const moved = moveBy(delta)\n    if (moved) event.preventDefault()\n    return moved\n  }\n\n  return { rovingKey, tabindexFor, setActive, reset, focusKey, moveBy, moveToEdge, handleNavigationKeys }\n}\n"],"mappings":"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"}