@pgcorp/ui-kit 0.10.0 → 0.10.2

package/src/internal/feedbackPresentation.ts

@@ -1,155 +0,0 @@
-import type { Component } from 'vue'
-
-import { AlertTriangle, CheckCircle2, Info, LoaderCircle, XCircle } from '../components/icons/sputnigUiIcons'
-import { createUiKitTranslate, UI_KIT_MESSAGES } from '../locales/messages'
-import type { UiKitStaticMessageKey, UiKitTranslate } from '../locales/locale'
-
-export type FeedbackTone = 'neutral' | 'info' | 'success' | 'warn' | 'danger'
-export type FeedbackSeverity = Exclude<FeedbackTone, 'neutral'>
-export type FeedbackLiveMode = 'off' | 'polite' | 'assertive' | 'auto'
-export type AsyncFeedbackStatus = 'loading' | 'empty' | 'error'
-export type FeedbackIndicatorState = FeedbackTone | 'progress'
-
-export interface FeedbackPresentation {
-  icon: Component
-  iconName: 'info' | 'check-circle' | 'alert-triangle' | 'x-circle'
-  fallbackTitle: string
-}
-
-export interface FeedbackLiveAttributes {
-  role?: 'status' | 'alert'
-  ariaLive?: 'polite' | 'assertive'
-  ariaAtomic?: 'true'
-}
-
-export interface AsyncFeedbackPresentation {
-  readonly tone: FeedbackTone
-  readonly icon: Component | null
-  readonly iconName: FeedbackPresentation['iconName'] | 'loader-circle' | null
-  readonly fallbackMessage: string
-  readonly busy: boolean
-  readonly live: Readonly<FeedbackLiveAttributes>
-}
-
-export interface FeedbackIndicatorPresentation {
-  readonly tone: FeedbackTone
-  readonly icon: Component
-  readonly iconName: FeedbackPresentation['iconName'] | 'loader-circle'
-  readonly fallbackTitle: string
-  readonly motion: 'static' | 'spin'
-}
-
-interface FeedbackPresentationSeed {
-  readonly icon: Component
-  readonly iconName: FeedbackPresentation['iconName']
-  readonly fallbackTitleKey: UiKitStaticMessageKey
-}
-
-const presentations: Readonly<Record<FeedbackTone, FeedbackPresentationSeed>> = {
-  neutral: { icon: Info, iconName: 'info', fallbackTitleKey: 'feedback.titleStatus' },
-  info: { icon: Info, iconName: 'info', fallbackTitleKey: 'feedback.titleInformation' },
-  success: { icon: CheckCircle2, iconName: 'check-circle', fallbackTitleKey: 'feedback.titleSuccess' },
-  warn: { icon: AlertTriangle, iconName: 'alert-triangle', fallbackTitleKey: 'feedback.titleWarning' },
-  danger: { icon: XCircle, iconName: 'x-circle', fallbackTitleKey: 'feedback.titleError' },
-}
-const defaultTranslate = createUiKitTranslate(() => UI_KIT_MESSAGES.ru)
-
-/**
- * Возвращает единую icon/title-презентацию для feedback tone.
- * Returns the canonical icon/title presentation for a feedback tone.
- */
-export function resolveFeedbackPresentation(
-  tone: FeedbackTone,
-  t: UiKitTranslate = defaultTranslate,
-): Readonly<FeedbackPresentation> {
-  const presentation = presentations[tone]
-  return {
-    icon: presentation.icon,
-    iconName: presentation.iconName,
-    fallbackTitle: t(presentation.fallbackTitleKey),
-  }
-}
-
-/**
- * Возвращает единственный icon/tone/motion contract для status indicator.
- * Returns the canonical icon/tone/motion contract for a status indicator.
- */
-export function resolveFeedbackIndicator(
-  state: FeedbackIndicatorState,
-  t: UiKitTranslate = defaultTranslate,
-): Readonly<FeedbackIndicatorPresentation> {
-  if (state === 'progress') {
-    return {
-      tone: 'info',
-      icon: LoaderCircle,
-      iconName: 'loader-circle',
-      fallbackTitle: t('feedback.titleRunning'),
-      motion: 'spin',
-    }
-  }
-  const presentation = resolveFeedbackPresentation(state, t)
-  return {
-    tone: state,
-    icon: presentation.icon,
-    iconName: presentation.iconName,
-    fallbackTitle: presentation.fallbackTitle,
-    motion: 'static',
-  }
-}
-
-/**
- * Выражает live-region contract без привязки к визуальному компоненту.
- * Resolves live-region semantics independently from a visual component.
- */
-export function resolveFeedbackLive(
-  tone: FeedbackTone,
-  mode: FeedbackLiveMode,
-): Readonly<FeedbackLiveAttributes> {
-  if (mode === 'off') return {}
-  const politeness = mode === 'auto' ? (tone === 'danger' ? 'assertive' : 'polite') : mode
-  return {
-    role: politeness === 'assertive' ? 'alert' : 'status',
-    ariaLive: politeness,
-    ariaAtomic: 'true',
-  }
-}
-
-/**
- * Возвращает единый визуальный и live-region contract для async surface state.
- * Returns the canonical visual and live-region contract for an async surface state.
- */
-export function resolveAsyncFeedbackPresentation(
-  status: AsyncFeedbackStatus,
-  t: UiKitTranslate = defaultTranslate,
-): Readonly<AsyncFeedbackPresentation> {
-  if (status === 'loading') {
-    const progress = resolveFeedbackIndicator('progress', t)
-    return {
-      tone: progress.tone,
-      icon: progress.icon,
-      iconName: progress.iconName,
-      fallbackMessage: t('feedback.loading'),
-      busy: true,
-      live: resolveFeedbackLive(progress.tone, 'auto'),
-    }
-  }
-  if (status === 'empty') {
-    return {
-      tone: 'neutral',
-      icon: null,
-      iconName: null,
-      fallbackMessage: t('feedback.empty'),
-      busy: false,
-      live: resolveFeedbackLive('neutral', 'auto'),
-    }
-  }
-  const error = resolveFeedbackIndicator('danger', t)
-  return {
-    tone: 'danger',
-    icon: error.icon,
-    iconName: error.iconName,
-    fallbackMessage: error.fallbackTitle,
-    busy: false,
-    live: resolveFeedbackLive('danger', 'auto'),
-  }
-}

package/src/internal/fieldPresentation.ts

@@ -1,28 +0,0 @@
-import { computed, type ComputedRef } from 'vue'
-
-export const FIELD_REQUIRED_CLASS = 'ml-0.5 text-danger-600 dark:text-danger-400'
-export const FIELD_SUPPORT_CLASS = 'mt-1 min-w-0 whitespace-normal text-xs [overflow-wrap:anywhere]'
-export const FIELD_HELP_CLASS = `${FIELD_SUPPORT_CLASS} text-surface-500 dark:text-surface-400`
-export const FIELD_ERROR_CLASS = `${FIELD_SUPPORT_CLASS} text-danger-600 dark:text-danger-400`
-
-export interface FieldSupportingTextOptions {
-  readonly baseId: ComputedRef<string>
-  readonly hasHelp: () => boolean
-  readonly hasError: () => boolean
-}
-
-/**
- * Владеет exact ID и aria-describedby contract для help/error у field и fieldset.
- * Owns the exact help/error ID and aria-describedby contract for fields and fieldsets.
- */
-export function useFieldSupportingText(options: FieldSupportingTextOptions) {
-  const helpId = computed(() => `${options.baseId.value}-help`)
-  const errorId = computed(() => `${options.baseId.value}-error`)
-  const describedBy = computed(() => {
-    const ids: string[] = []
-    if (options.hasHelp()) ids.push(helpId.value)
-    if (options.hasError()) ids.push(errorId.value)
-    return ids.length > 0 ? ids.join(' ') : undefined
-  })
-  return { describedBy, errorId, helpId } as const
-}

package/src/internal/fieldSurface.ts

@@ -1,59 +0,0 @@
-import { validateBoolean, validateExactString, validateNonEmptyString } from './runtimeContract'
-
-const FIELD_SURFACE_KINDS = [
-  'text-input',
-  'textarea',
-  'inline-token-editor',
-  'combobox-trigger',
-] as const
-const FIELD_SURFACE_APPEARANCES = ['field', 'ghost', 'embedded'] as const
-
-/** Canonical owners sharing one field-surface visual contract. / Канонические владельцы общего визуального контракта field surface. */
-export type FieldSurfaceKind = typeof FIELD_SURFACE_KINDS[number]
-/** Canonical participation mode in the shared field surface. / Режим участия в общей field surface. */
-export type FieldSurfaceAppearance = typeof FIELD_SURFACE_APPEARANCES[number]
-
-export interface FieldSurfaceContract {
-  kind: FieldSurfaceKind
-  appearance: FieldSurfaceAppearance
-  invalid: boolean
-  disabled: boolean
-  readonly: boolean
-}
-
-export interface FieldSurfaceBindings {
-  'data-s-field-surface': FieldSurfaceKind
-  'data-s-field-appearance': FieldSurfaceAppearance
-  'data-s-field-invalid'?: 'true'
-  'data-s-field-disabled'?: 'true'
-  'data-s-field-readonly'?: 'true'
-}
-
-/**
- * Создаёт exact DOM bindings единого field-surface foundation без truthy coercion.
- * Creates exact DOM bindings for the shared field-surface foundation without truthy coercion.
- */
-export function resolveFieldSurfaceBindings(
-  owner: string,
-  contract: FieldSurfaceContract,
-): FieldSurfaceBindings {
-  validateNonEmptyString('fieldSurface', 'owner', owner)
-  const kind = validateExactString(owner, 'field surface kind', contract.kind, FIELD_SURFACE_KINDS)
-  const appearance = validateExactString(
-    owner,
-    'field surface appearance',
-    contract.appearance,
-    FIELD_SURFACE_APPEARANCES,
-  )
-  const invalid = validateBoolean(owner, 'field surface invalid', contract.invalid)
-  const disabled = validateBoolean(owner, 'field surface disabled', contract.disabled)
-  const readonly = validateBoolean(owner, 'field surface readonly', contract.readonly)
-
-  return {
-    'data-s-field-surface': kind,
-    'data-s-field-appearance': appearance,
-    ...(invalid ? { 'data-s-field-invalid': 'true' as const } : {}),
-    ...(disabled ? { 'data-s-field-disabled': 'true' as const } : {}),
-    ...(readonly ? { 'data-s-field-readonly': 'true' as const } : {}),
-  }
-}

package/src/internal/focusNavigation.ts

@@ -1,69 +0,0 @@
-const FOCUSABLE_SELECTOR = [
-  'a[href]',
-  'button:not([disabled])',
-  'textarea:not([disabled])',
-  'input:not([disabled])',
-  'select:not([disabled])',
-  '[contenteditable="true"]',
-  '[tabindex]:not([tabindex="-1"])',
-].join(', ')
-
-const isSemanticallyVisible = (element: HTMLElement): boolean => {
-  if (element.hidden || element.closest('[inert]') || element.closest('[aria-hidden="true"]')) return false
-  const style = window.getComputedStyle(element)
-  return style.display !== 'none' && style.visibility !== 'hidden'
-}
-
-/** Проверяет programmatic/browser focus owner без layout-эвристик. / Checks a programmatic/browser focus owner without layout heuristics. */
-export const isFocusableElement = (element: HTMLElement): boolean => (
-  element.matches(FOCUSABLE_SELECTOR) && isSemanticallyVisible(element)
-)
-
-/**
- * Поднимает произвольный event target до ближайшего canonical focus owner внутри optional boundary.
- * Lifts an arbitrary event target to the nearest canonical focus owner inside an optional boundary.
- */
-export const findFocusableOwner = (
-  target: EventTarget | null,
-  boundary?: ParentNode | null,
-): HTMLElement | null => {
-  const targetElement = target instanceof Element
-    ? target
-    : target instanceof Node
-      ? target.parentElement
-      : null
-  const owner = targetElement?.closest<HTMLElement>(FOCUSABLE_SELECTOR) ?? null
-  if (!owner || !isFocusableElement(owner)) return null
-  if (boundary instanceof Node && !boundary.contains(owner)) return null
-  return owner
-}
-
-export const getFocusableElements = (
-  root: ParentNode,
-  options: { requireLayout?: boolean } = {},
-): HTMLElement[] => [...root.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)].filter((element) => {
-  if (!isFocusableElement(element)) return false
-  if (!options.requireLayout) return true
-  return element.offsetParent !== null || element.getClientRects().length > 0
-})
-
-export const findRelativeTabTarget = (
-  reference: HTMLElement,
-  scope: ParentNode,
-  excludedRoot: HTMLElement | null,
-  reverse: boolean,
-): HTMLElement | null => {
-  const candidates = getFocusableElements(scope).filter((element) => !excludedRoot?.contains(element))
-  if (candidates.length === 0) return null
-  const exactIndex = candidates.indexOf(reference)
-  if (exactIndex >= 0) {
-    const offset = reverse ? -1 : 1
-    return candidates[(exactIndex + offset + candidates.length) % candidates.length] ?? null
-  }
-
-  const ordered = reverse ? [...candidates].reverse() : candidates
-  const relation = reverse ? Node.DOCUMENT_POSITION_PRECEDING : Node.DOCUMENT_POSITION_FOLLOWING
-  return ordered.find((candidate) => Boolean(reference.compareDocumentPosition(candidate) & relation))
-    ?? ordered[0]
-    ?? null
-}

package/src/internal/inlineTokenEditorContract.ts

@@ -1,137 +0,0 @@
-import { validateBoundedInteger, validateNonEmptyString } from './runtimeContract'
-import { hasOwn, lastItem } from './es2020'
-
-export type InlineTokenEditorSegmentContract =
-  | { readonly kind: 'text'; readonly text: string }
-  | {
-    readonly kind: 'token'
-    readonly occurrenceId: string
-    readonly id: string
-    readonly label: string
-    readonly title?: string
-  }
-
-function assertPlainRecord(owner: string, value: unknown): Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype) {
-    throw new TypeError(`${owner}: значение должно быть plain object. / ${owner}: value must be a plain object.`)
-  }
-  return value as Record<string, unknown>
-}
-
-function assertExactKeys(owner: string, record: Record<string, unknown>, allowed: readonly string[]): void {
-  const unexpected = Object.keys(record).filter((key) => !allowed.includes(key))
-  if (unexpected.length > 0) {
-    throw new TypeError(`${owner}: неизвестные поля ${unexpected.map((key) => JSON.stringify(key)).join(', ')}. / ${owner}: unknown fields ${unexpected.map((key) => JSON.stringify(key)).join(', ')}.`)
-  }
-}
-
-/** Собирает plain-text mirror без нормализации сегментов. / Builds the plain-text mirror without normalizing segments. */
-export function inlineTokenSegmentsToText(segments: readonly InlineTokenEditorSegmentContract[]): string {
-  return segments.map((segment) => segment.kind === 'text' ? segment.text : segment.label).join('')
-}
-
-/** Проверяет canonical external segment source и его exact model mirror. / Validates the canonical external segment source and its exact model mirror. */
-export function parseInlineTokenEditorSource(
-  modelValue: unknown,
-  segments: unknown,
-): readonly InlineTokenEditorSegmentContract[] {
-  if (typeof modelValue !== 'string') {
-    throw new TypeError('SInlineTokenEditor: modelValue должен быть строкой. / SInlineTokenEditor: modelValue must be a string.')
-  }
-  if (!Array.isArray(segments)) {
-    throw new TypeError('SInlineTokenEditor: segments должен быть массивом. / SInlineTokenEditor: segments must be an array.')
-  }
-
-  const parsed: InlineTokenEditorSegmentContract[] = []
-  const tokenOccurrences = new Map<string, number>()
-  for (let index = 0; index < segments.length; index += 1) {
-    if (!hasOwn(segments, index)) {
-      throw new TypeError(`SInlineTokenEditor: segments[${index}] отсутствует в sparse array. / SInlineTokenEditor: segments[${index}] is missing from a sparse array.`)
-    }
-    const record = assertPlainRecord(`SInlineTokenEditor.segments[${index}]`, segments[index])
-    if (record.kind === 'text') {
-      assertExactKeys(`SInlineTokenEditor.segments[${index}]`, record, ['kind', 'text'])
-      if (typeof record.text !== 'string' || record.text.length === 0) {
-        throw new TypeError(`SInlineTokenEditor: segments[${index}].text должен быть непустой строкой. / SInlineTokenEditor: segments[${index}].text must be a non-empty string.`)
-      }
-      const text = record.text
-      if (lastItem(parsed)?.kind === 'text') {
-        throw new TypeError(`SInlineTokenEditor: segments[${index}] является смежным text segment; объедините его в источнике. / SInlineTokenEditor: segments[${index}] is an adjacent text segment; merge it at the source.`)
-      }
-      parsed.push({ kind: 'text', text })
-      continue
-    }
-    if (record.kind !== 'token') {
-      throw new TypeError(`SInlineTokenEditor: segments[${index}].kind должен быть "text" или "token". / SInlineTokenEditor: segments[${index}].kind must be "text" or "token".`)
-    }
-    assertExactKeys(`SInlineTokenEditor.segments[${index}]`, record, ['kind', 'occurrenceId', 'id', 'label', 'title'])
-    const occurrenceId = validateNonEmptyString(
-      'SInlineTokenEditor', `segments[${index}].occurrenceId`, record.occurrenceId,
-    )
-    const firstOccurrenceIndex = tokenOccurrences.get(occurrenceId)
-    if (firstOccurrenceIndex !== undefined) {
-      throw new TypeError(`SInlineTokenEditor: segments[${index}].occurrenceId дублирует ${JSON.stringify(occurrenceId)} из segments[${firstOccurrenceIndex}].occurrenceId. / SInlineTokenEditor: segments[${index}].occurrenceId duplicates ${JSON.stringify(occurrenceId)} from segments[${firstOccurrenceIndex}].occurrenceId.`)
-    }
-    tokenOccurrences.set(occurrenceId, index)
-    const title = record.title === undefined
-      ? undefined
-      : validateNonEmptyString('SInlineTokenEditor', `segments[${index}].title`, record.title)
-    parsed.push({
-      kind: 'token',
-      occurrenceId,
-      id: validateNonEmptyString('SInlineTokenEditor', `segments[${index}].id`, record.id),
-      label: validateNonEmptyString('SInlineTokenEditor', `segments[${index}].label`, record.label),
-      ...(title === undefined ? {} : { title }),
-    })
-  }
-
-  const mirror = inlineTokenSegmentsToText(parsed)
-  if (modelValue !== mirror) {
-    throw new TypeError(`SInlineTokenEditor: modelValue не совпадает с text mirror segments; ожидалось ${JSON.stringify(mirror)}, получено ${JSON.stringify(modelValue)}. / SInlineTokenEditor: modelValue does not match the segments text mirror; expected ${JSON.stringify(mirror)}, received ${JSON.stringify(modelValue)}.`)
-  }
-  return parsed
-}
-
-/** Проверяет cursor offset относительно exact logical text. / Validates a cursor offset against exact logical text. */
-export function validateInlineTokenCursorOffset(value: unknown, textLength: number, coordinate: string): number {
-  return validateBoundedInteger('SInlineTokenEditor', coordinate, value, { minimum: 0, maximum: textLength })
-}
-
-/** Запрещает cursor внутри atomic token label; разрешены только его границы. / Rejects cursor positions inside an atomic token label; only its boundaries are addressable. */
-export function validateInlineTokenCursorBoundary(
-  segments: readonly InlineTokenEditorSegmentContract[],
-  value: unknown,
-  coordinate: string,
-): number {
-  const offset = validateInlineTokenCursorOffset(value, inlineTokenSegmentsToText(segments).length, coordinate)
-  let segmentStart = 0
-  for (const segment of segments) {
-    const segmentEnd = segmentStart + (segment.kind === 'text' ? segment.text.length : segment.label.length)
-    if (segment.kind === 'token' && offset > segmentStart && offset < segmentEnd) {
-      throw new RangeError(`SInlineTokenEditor: ${coordinate}=${offset} попадает внутрь atomic token occurrence ${JSON.stringify(segment.occurrenceId)}; допустимы ${segmentStart} или ${segmentEnd}. / SInlineTokenEditor: ${coordinate}=${offset} falls inside atomic token occurrence ${JSON.stringify(segment.occurrenceId)}; use ${segmentStart} or ${segmentEnd}.`)
-    }
-    segmentStart = segmentEnd
-  }
-  return offset
-}
-
-/** Создаёт canonical internally-generated sequence; external invalid input сюда не попадает. / Creates a canonical internally-generated sequence; external invalid input never enters this path. */
-export function composeInlineTokenSegments(
-  segments: readonly InlineTokenEditorSegmentContract[],
-): InlineTokenEditorSegmentContract[] {
-  const result: InlineTokenEditorSegmentContract[] = []
-  for (const segment of segments) {
-    if (segment.kind === 'text') {
-      if (segment.text.length === 0) continue
-      const previous = lastItem(result)
-      if (previous?.kind === 'text') {
-        result[result.length - 1] = { kind: 'text', text: previous.text + segment.text }
-      } else {
-        result.push({ kind: 'text', text: segment.text })
-      }
-    } else {
-      result.push({ ...segment })
-    }
-  }
-  return [...parseInlineTokenEditorSource(inlineTokenSegmentsToText(result), result)]
-}

package/src/internal/interactiveElement.ts

@@ -1,33 +0,0 @@
-/**
- * Типизированная element/focus-поверхность UI-kit leaf для составных владельцев.
- * Typed element/focus surface exposed by a UI-kit leaf to composite owners.
- */
-export interface ElementApi<TElement extends HTMLElement = HTMLElement> {
-  getElement: () => TElement
-}
-
-export interface InteractiveElementApi<TElement extends HTMLElement = HTMLElement> extends ElementApi<TElement> {
-  focus: (options?: FocusOptions) => void
-}
-
-export type ElementRefTarget = Element | ElementApi | ComponentPublicInstance | null
-export type InteractiveElementRefTarget = Element | InteractiveElementApi | ComponentPublicInstance | null
-
-/** Разрешает callback-ref только через native HTMLElement или публичный leaf API. / Resolves a callback ref only through a native HTMLElement or a public leaf API. */
-export function resolveInteractiveElement(
-  owner: string,
-  target: ElementRefTarget,
-): HTMLElement | null {
-  if (target === null) return null
-  if (target instanceof HTMLElement) return target
-  const getElement = Reflect.get(target, 'getElement')
-  if (typeof getElement !== 'function') {
-    throw new TypeError(`${owner}: ref must resolve to an HTMLElement or ElementApi`)
-  }
-  const element: unknown = Reflect.apply(getElement, target, [])
-  if (!(element instanceof HTMLElement)) {
-    throw new TypeError(`${owner}: ElementApi.getElement() must return an HTMLElement`)
-  }
-  return element
-}
-import type { ComponentPublicInstance } from 'vue'

package/src/internal/layerStack.ts

@@ -1,202 +0,0 @@
-import { isFocusableElement } from './focusNavigation'
-
-export type LayerKind = 'dialog' | 'listbox' | 'menu' | 'popover' | 'tooltip'
-export type LayerDismissReason = 'escape' | 'outside-contextmenu' | 'outside-pointer'
-
-export interface LayerRegistrationOptions {
-  kind: LayerKind
-  root: () => HTMLElement | null
-  anchor?: () => HTMLElement | null
-  branches?: () => readonly HTMLElement[]
-  modal?: boolean
-  restoreTarget?: HTMLElement | null
-  dismissOnEscape?: () => boolean
-  dismissOnOutsidePointer?: () => boolean
-  blocksParentFocusTrap?: boolean
-  trapFocus?: (event: KeyboardEvent) => void
-  requestDismiss: (reason: LayerDismissReason, event: Event) => void
-}
-
-export interface LayerRegistration {
-  readonly id: symbol
-  readonly zIndex: string
-  readonly focusScope: () => ParentNode
-  unregister: (options?: { restoreFocus?: boolean }) => void
-}
-
-interface LayerEntry extends LayerRegistrationOptions {
-  id: symbol
-  parentId: symbol | null
-  restoreTarget: HTMLElement | null
-  tier: 'floating' | 'overlay'
-  zIndex: string
-}
-
-const layers: LayerEntry[] = []
-let listenersAttached = false
-let bodyLockCount = 0
-let preservedBodyOverflow = ''
-
-const entryContains = (entry: LayerEntry, target: Node): boolean => {
-  if (entry.root()?.contains(target) || entry.anchor?.()?.contains(target)) return true
-  return entry.branches?.().some((branch) => branch.contains(target)) ?? false
-}
-
-const findParentId = (options: LayerRegistrationOptions): symbol | null => {
-  const reference = options.anchor?.()
-    ?? options.restoreTarget
-    ?? (typeof document !== 'undefined' && document.activeElement instanceof HTMLElement
-      ? document.activeElement
-      : null)
-  if (!reference) return null
-  return [...layers].reverse().find((entry) => entryContains(entry, reference))?.id ?? null
-}
-
-const topmostLayer = (): LayerEntry | undefined => layers[layers.length - 1]
-
-const resolveFocusScope = (entry: LayerEntry): ParentNode => {
-  let parentId = entry.parentId
-  while (parentId) {
-    const parent = layers.find((candidate) => candidate.id === parentId)
-    if (!parent) break
-    if (parent.modal || parent.trapFocus) {
-      return parent.root() ?? document
-    }
-    parentId = parent.parentId
-  }
-  return document
-}
-
-const handleGlobalKeydown = (event: KeyboardEvent): void => {
-  const topmost = topmostLayer()
-  if (!topmost) return
-
-  if (event.key === 'Escape') {
-    if (topmost.dismissOnEscape?.() ?? true) {
-      event.preventDefault()
-      event.stopPropagation()
-      topmost.requestDismiss('escape', event)
-    }
-    return
-  }
-
-  if (event.key !== 'Tab') return
-  let trapIndex = -1
-  for (let index = layers.length - 1; index >= 0; index -= 1) {
-    if (layers[index]?.trapFocus) {
-      trapIndex = index
-      break
-    }
-  }
-  if (trapIndex < 0) return
-  const blockedByChild = layers
-    .slice(trapIndex + 1)
-    .some((entry) => entry.blocksParentFocusTrap ?? true)
-  if (!blockedByChild) layers[trapIndex]?.trapFocus?.(event)
-}
-
-const handleGlobalOutsideEvent = (event: Event, reason: LayerDismissReason): void => {
-  const topmost = topmostLayer()
-  if (!topmost) return
-  const target = event.target
-  if (target instanceof Node && entryContains(topmost, target)) return
-  if (topmost.dismissOnOutsidePointer?.() ?? true) topmost.requestDismiss(reason, event)
-}
-
-const handleGlobalPointerDown = (event: PointerEvent): void => {
-  handleGlobalOutsideEvent(event, 'outside-pointer')
-}
-
-const handleGlobalContextMenu = (event: MouseEvent): void => {
-  handleGlobalOutsideEvent(event, 'outside-contextmenu')
-}
-
-const attachListeners = (): void => {
-  if (listenersAttached || typeof window === 'undefined' || typeof document === 'undefined') return
-  listenersAttached = true
-  window.addEventListener('keydown', handleGlobalKeydown, true)
-  document.addEventListener('pointerdown', handleGlobalPointerDown, true)
-  document.addEventListener('contextmenu', handleGlobalContextMenu, true)
-}
-
-const detachListeners = (): void => {
-  if (!listenersAttached || layers.length > 0 || typeof window === 'undefined' || typeof document === 'undefined') return
-  listenersAttached = false
-  window.removeEventListener('keydown', handleGlobalKeydown, true)
-  document.removeEventListener('pointerdown', handleGlobalPointerDown, true)
-  document.removeEventListener('contextmenu', handleGlobalContextMenu, true)
-}
-
-const lockBody = (): void => {
-  if (typeof document === 'undefined') return
-  if (bodyLockCount === 0) {
-    preservedBodyOverflow = document.body.style.overflow
-    document.body.style.overflow = 'hidden'
-  }
-  bodyLockCount += 1
-}
-
-const unlockBody = (): void => {
-  if (typeof document === 'undefined') return
-  bodyLockCount = Math.max(0, bodyLockCount - 1)
-  if (bodyLockCount === 0) document.body.style.overflow = preservedBodyOverflow
-}
-
-const scheduleFocusRestore = (entry: LayerEntry): void => {
-  queueMicrotask(() => {
-    if (entry.restoreTarget?.isConnected && isFocusableElement(entry.restoreTarget)) {
-      entry.restoreTarget.focus()
-      return
-    }
-    topmostLayer()?.root()?.focus()
-  })
-}
-
-/**
- * Регистрирует одну открытую overlay-поверхность в общем dismiss/focus/body-lock стеке.
- * Registers one open overlay surface in the shared dismiss/focus/body-lock stack.
- */
-export function registerLayer(options: LayerRegistrationOptions): LayerRegistration {
-  const previousTopmost = topmostLayer()
-  const tier = options.modal || previousTopmost?.tier === 'overlay' ? 'overlay' : 'floating'
-  const zIndex = previousTopmost && previousTopmost.tier === tier
-    ? `calc(${previousTopmost.zIndex} + var(--s-layer-overlay-step))`
-    : tier === 'overlay'
-      ? 'var(--s-layer-root-overlay-backdrop)'
-      : 'var(--s-layer-root-floating)'
-  const entry: LayerEntry = {
-    ...options,
-    id: Symbol(options.kind),
-    parentId: findParentId(options),
-    restoreTarget: options.restoreTarget ?? null,
-    tier,
-    zIndex,
-  }
-  let registered = true
-  layers.push(entry)
-  if (entry.modal) lockBody()
-  attachListeners()
-
-  return {
-    id: entry.id,
-    zIndex: entry.zIndex,
-    focusScope: () => resolveFocusScope(entry),
-    unregister: ({ restoreFocus = false } = {}) => {
-      if (!registered) return
-      registered = false
-      const index = layers.findIndex((candidate) => candidate.id === entry.id)
-      const wasTopmost = index === layers.length - 1
-      if (index >= 0) {
-        const removedRoot = entry.root()
-        for (const layer of layers.slice(index + 1)) {
-          if (layer.parentId === entry.id) layer.parentId = entry.parentId
-          if (removedRoot?.contains(layer.restoreTarget)) layer.restoreTarget = entry.restoreTarget
-        }
-        layers.splice(index, 1)
-      }
-      if (entry.modal) unlockBody()
-      detachListeners()
-      if (restoreFocus && wasTopmost) scheduleFocusRestore(entry)
-    },
-  }
-}