@soxa-ui/plugins 0.0.0-stage → 0.3.0-beta.1

package/dist/custom/field/ids/ids.plugin.js

@@ -0,0 +1,126 @@
+import { TBasePlugin } from "../../../base/base.class.js";
+//#region src/custom/field/ids/ids.plugin.ts
+/** Ссылок нет: ни одна часть не рисуется. */
+var NO_LINKS = {};
+/**
+* TFieldIdsPlugin — связки поля формы в документе: подпись, подсказка и ошибка
+* с контролом.
+*
+* `id` частей — в их наборы (`labelAria`, `helperAria`, `errorAria`), от
+* монтирования поля (`createId`), а не от экземпляра: они нужны только
+* документу, и на сервере и в браузере обязаны совпасть. Пишутся при
+* установке, синхронно, — связка есть уже в первой (и серверной) отрисовке.
+*
+* **Ссылки контрола на части** (`links`) плагин считает, а пишет их в `aria`
+* контрола связка поля с контролом — через его `TAriaPlugin`: часть
+* подписи — пока подпись рисуется, справка — та, что видна: ошибка, а без неё
+* подсказка. Сменилась видимая часть — `change:links`.
+*
+* **`for` подписи** — `<id монтирования>-control` (`controlId`): этот же `id`
+* labelable-контрол без своего получает от связки своим `id`, и подпись
+* называет его и передаёт ему клик с первой отрисовки. Принятый контрол
+* сообщает о себе (`bindControl`): `for` ведёт на его `id`, а у группы
+* (DateInput, DatePicker, RadioGroup) `for` снят — её подпись называет
+* ссылкой `aria-labelledby`. Снятый контрол (`unbindControl`) возвращает
+* `for` к `controlId`. Контрол у поля один: связку берёт первый.
+*/
+var TFieldIdsPlugin = class extends TBasePlugin {
+	_field = null;
+	_labelId = "";
+	_helperId = "";
+	_errorId = "";
+	_controlId = "";
+	_links = NO_LINKS;
+	_control = null;
+	install(ctx) {
+		super.install(ctx);
+		const field = ctx.getInstance();
+		if (!field) return;
+		this._field = field;
+		this._labelId = ctx.createId("label");
+		this._helperId = ctx.createId("helper");
+		this._errorId = ctx.createId("error");
+		this._controlId = ctx.createId("control");
+		field.labelAria.add("id", this._labelId);
+		field.helperAria.add("id", this._helperId);
+		field.errorAria.add("id", this._errorId);
+		this._syncFor();
+		this._links = this._linksOf(field);
+		const relink = () => this._relink(field);
+		this._listenTo(field.events, "change:label", relink);
+		this._listenTo(field.events, "change:helper", relink);
+		this._listenTo(field.events, "change:error", relink);
+		this._listenTo(field.events, "change:invalid", relink);
+	}
+	/**
+	* `id` поля контрола от поля: его получает labelable-контрол без своего
+	* `id`, на него ведёт `for` подписи.
+	*/
+	get controlId() {
+		return this._controlId;
+	}
+	/** Ссылки контрола на видимые части. Новый объект на каждую смену. */
+	get links() {
+		return this._links;
+	}
+	/** Занята ли связка: контрол у поля один. */
+	get bound() {
+		return this._control !== null;
+	}
+	/**
+	* Контрол приняли — `for` подписи по нему. Зовёт связка и на смену `id`
+	* контрола.
+	*/
+	bindControl(control) {
+		this._control = control;
+		this._syncFor();
+	}
+	/** Контрол сняли: связка свободна, `for` — снова на `controlId`. */
+	unbindControl() {
+		this._control = null;
+		this._syncFor();
+	}
+	destroy() {
+		this._field = null;
+		this._control = null;
+		this._links = NO_LINKS;
+		super.destroy();
+	}
+	_syncFor() {
+		this._field?.labelAria.add("for", this._forOf(this._control));
+	}
+	/**
+	* `for` подписи: свой `id` поля контрола или `controlId`; у группы — нет:
+	* `for` называет только labelable-элемент.
+	*/
+	_forOf(control) {
+		if (control === null) return this._controlId;
+		if (!control.labelable) return null;
+		return control.id ?? this._controlId;
+	}
+	_relink(field) {
+		const oldLinks = this.links;
+		const links = this._linksOf(field);
+		const current = this._links;
+		if (links.labelledBy === current.labelledBy && links.describedBy === current.describedBy) return;
+		this._links = links;
+		this.events.emit("change:links", {
+			newValue: links,
+			oldValue: oldLinks
+		});
+	}
+	/** Ссылки — на части, которые рисуются: подпись с текстом и видимую справку. */
+	_linksOf(field) {
+		return {
+			labelledBy: field.label !== "" ? this._labelId : void 0,
+			describedBy: this._describedByOf(field)
+		};
+	}
+	/** Видимая справка: ошибка, а без неё — подсказка. */
+	_describedByOf(field) {
+		if (field.errorRendered) return this._errorId;
+		if (field.helperRendered) return this._helperId;
+	}
+};
+//#endregion
+export { TFieldIdsPlugin };

package/dist/custom/field/ids/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ids.plugin';
+export type { IFieldControlInfo, IFieldLinks, TFieldIdsPluginEvents } from './types';

package/dist/custom/field/ids/types.d.ts

@@ -0,0 +1,28 @@
+import type { TValuePayload } from '@soxa-ui/core';
+import type { TPluginEvents } from '../../../base';
+/**
+ * Ссылки контрола на части поля — то, что поле даёт `aria` своего контрола.
+ *
+ * Пары «есть / нет»: части без текста в разметке нет, и ссылки на неё нет
+ * тоже — иначе контрол ссылался бы на `id`, которого в документе нет.
+ */
+export interface IFieldLinks {
+    /** `id` подписи — пока она рисуется (задан её текст) */
+    readonly labelledBy?: string;
+    /** `id` видимой справки: ошибки, а без неё — подсказки */
+    readonly describedBy?: string;
+}
+/**
+ * Что контрол сообщает о себе полю, когда его приняли: по этому плагин решает
+ * `for` подписи.
+ */
+export interface IFieldControlInfo {
+    /** `id` поля контрола — свой или заданный полем; у контрола без `id` — `undefined` */
+    readonly id: string | undefined;
+    /** Labelable ли элемент с `aria`: группу `for` подписи не называет */
+    readonly labelable: boolean;
+}
+export type TFieldIdsPluginEvents = TPluginEvents & {
+    /** change:links — ссылки контрола на части сменились: появилась, пропала или сменилась часть */
+    'change:links': (payload: TValuePayload<IFieldLinks>) => void;
+};

package/dist/custom/field/index.d.ts

@@ -0,0 +1 @@
+export * from './ids';

package/dist/custom/frame/anchor/anchor.plugin.d.ts

@@ -0,0 +1,483 @@
+import type { TDefaultValues } from '@soxa-ui/core';
+import { TBasePlugin } from '../../../base';
+import type { IPluginContext } from '../../../base';
+import type { TPoint } from '../../../utils';
+import type { IAnchorPluginOptions, IAnchorPluginProps, TAnchorPluginEvents, TFramePlacement } from './types';
+/**
+ * Атрибут фактической стороны панели после flip: плагин пишет его в `dataset`
+ * Frame. Читают его тема и плагин жеста (`TSwipePlugin`): панель у триггера
+ * уходит жестом от него, а под ним она или над ним, знает только её узел.
+ *
+ * Имя с префиксом `data-`: по нему читают узел, а `dataset` принимает имя с
+ * префиксом как есть.
+ */
+export declare const ANCHOR_PLACEMENT_ATTRIBUTE = "data-placement";
+/**
+ * TAnchorPlugin — привязка Frame к чужому элементу.
+ *
+ * Общий слой для всего, что открывается у чего-то: выпадающий список Select,
+ * меню у кнопки, поповер, подсказка. Сам ничего не рисует — вычисляет
+ * координаты и пишет их во Frame (`x`, `y`, при `matchWidth` ещё `width`).
+ * Дальше их раскладывает `TFrameLayoutPlugin`, как любые другие координаты.
+ *
+ * Разделение не формальное: раскладка отвечает за собственные пропсы Frame,
+ * привязка — за слежение за посторонним элементом. Смешивать их значит
+ * заводить в одном плагине два повода меняться.
+ *
+ * **Место считается, пока панель на экране** — показана или ещё гаснет.
+ * Закрытые панели у полей — списки Select, подсказки, меню, календари
+ * DatePicker — стоят на странице десятками, и каждая на каждом кадре
+ * прокрутки меряла бы свой якорь и писала бы во Frame новые координаты.
+ * Поэтому якорь плагин запоминает сразу, а слежение за ним (`_subscribe`)
+ * заводит показ Frame, у Frame, созданного видимым, — назначение якоря.
+ * Снимает его конец закрытия: когда корень доиграл переходы закрытия
+ * (`afterTransitions`), — гаснущая и уходящая жестом панель идёт за полем до
+ * конца. Новый показ ожидание отменяет. Снятие места — якоря, когда точки нет,
+ * и точки, когда нет якоря, — и `destroy()` снимают слежение сразу, снятый
+ * корень — тоже: панели на экране нет, и ждать её перехода незачем, — а новый
+ * корень показанной панели слежение возвращает.
+ * Вне слежения место не считает ничто — ни прокрутка, ни наблюдатель панели,
+ * ни сеттеры, — на любой стороне, сбоку тоже: показ считает его заново.
+ * Открытость плагин ведёт сам, по `show` и `hide` своего Frame, а не
+ * адаптер: якорь только у открытой панели развёл бы это правило по шести
+ * адаптерам.
+ *
+ * `placement` — сторона и выравнивание по якорю: `-start` — по началу, `-end` —
+ * по концу, без суффикса — по центру. Стороны блока, `top` и `bottom`, ставят
+ * панель над якорем или под ним, и выравнивание идёт вдоль строки. Стороны
+ * строки, `start` и `end`, ставят её у начала или конца строки якоря, и
+ * выравнивание идёт вдоль якоря по вертикали: `-start` — верхние края вровень,
+ * `-end` — нижние. Поверх этого выбора плагин сам решает две вещи:
+ * **flip** — если панель не влезает с выбранной стороны (сверху и снизу — по
+ * высоте, сбоку — по ширине), а с противоположной места больше, показывает её
+ * там; **shift** — сдвигает панель вдоль якоря, чтобы она не вылезала за край:
+ * у верха и низа — `x`, у боковой — `y`. Границей обоим служит видимая область
+ * окна, без классической полосы прокрутки (см. `_viewport`). Оба работают
+ * внутри тех же вариантов `placement`: flip переключает только сторону, на той
+ * же оси, — выравнивание, центр в том числе, остаётся, — а shift не меняет
+ * `placement` и только ограничивает координату. Flip выключается свойством
+ * `flip` (по умолчанию включён): панель остаётся на стороне потребителя, даже
+ * если там не влезает. Shift от него не зависит.
+ *
+ * Боковая панель сверх того прижимается к краям окна и по `x`: не влезла ни с
+ * одной стороны (узкий экран, широкое содержимое вроде календаря) — накрывает
+ * якорь, но видна целиком. У верха и низа этот случай закрывает потолок высоты
+ * панели в теме, а потолка ширины у произвольного содержимого нет.
+ *
+ * У flip есть память. Правило выше только выбирает сторону (`_chooseSide`), а
+ * открытая панель свою держит (`_holdSide`): пока на ней влезает — стоит, не
+ * влезла — переходит на противоположную, только если влезает там, не влезает
+ * нигде — стоит. Правило без памяти скакало: одна и та же граница «снизу
+ * влезает» и уводила панель наверх, и возвращала её вниз. На телефоне палец
+ * двигает страницу по пикселю туда и обратно, адресная строка браузера
+ * прячется и выезжает, и поле всё время стоит на этой границе, а на коротком
+ * экране, где панель не влезает нигде, сторона менялась на каждом переходе
+ * поля через середину экрана. Так же поступает CSS Anchor Positioning — держит
+ * последний удачный вариант. Сбоку правило и память те же, только место
+ * меряется по ширине: границу «сбоку влезает» якорь переходит при прокрутке
+ * вбок и смене ширины окна. Сторону забывают показ Frame, смена `placement` и
+ * `flip`, смена и снятие якоря и `contained`, и следующий расчёт выбирает её
+ * заново. Закрытие её не забывает: гаснущая панель держит сторону, как
+ * открытая.
+ *
+ * `RTL` (`getComputedStyle(anchor).direction`) разворачивает ось строки. У
+ * верха и низа — выравнивание: в RTL `-start` выравнивает панель по правому
+ * краю якоря, `-end` — по левому. У боковой — сторону: в RTL `start` справа
+ * от якоря, `end` — слева. Центр и выравнивание боковой панели по вертикали
+ * от направления не зависят.
+ *
+ * Фактическая сторона после flip уходит теме через `data-placement` на самом
+ * Frame (`frame.dataset`) — она не всегда совпадает с тем, что задал
+ * потребитель в `placement`. Выравнивание в ней — потребителя, а сторона
+ * логическая и в RTL: `end-start`, перенесённый flip-ом, — `start-start`.
+ *
+ * `position` панели у якоря выбирает плагин (`_choosePosition`), как пишет
+ * её `x` и `y`: `absolute`, а у якоря, который стоит в окне, — `fixed`.
+ * Панель `fixed` прокрутку страницы не замечает, и сдвинуть её за полем
+ * может только пересчёт по `scroll`. На телефоне страницу прокручивает
+ * композитор, а `scroll` приходит в JS кадром позже: поле уже уехало, панель
+ * кадр стоит и догоняет — дрожит на каждом кадре прокрутки. Ни кадр
+ * (`requestAnimationFrame`), ни память стороны этого не снимают. Панель
+ * `absolute` лежит в документе, и окно браузер прокручивает вместе с ней и
+ * полем, без JS, — так у PrimeVue. Якорь в окне (`fixed` или `sticky` к
+ * окну, `isPinnedToViewport`) прокрутка окна не двигает, и панель `absolute`
+ * отставала бы от него наоборот — у него `fixed`. Выбирают заново показ Frame
+ * и смена якоря у показанной панели.
+ *
+ * Внутренняя прокрутка — граница, а не недоделка. Поле в своём прокручиваемом
+ * блоке, а панель в `body`: её отставание на кадр снимет только CSS Anchor
+ * Positioning, где место считает браузер, — или `target` панели в самом
+ * блоке, и тогда она едет вместе с ним.
+ *
+ * **Точка** (`point`) — место вместо якоря: контекстное меню встаёт у места
+ * вызова, а не у области, в которой его вызвали. Точка главнее якоря, пока
+ * задана, — иначе выбирать, к чему привязать панель, пришлось бы шаблону, —
+ * а снятая возвращает панель к якорю. Это прямоугольник нулевого размера в
+ * координатах окна, и расчёт у него тот же: стороны, flip, shift, RTL
+ * (направление — якоря, без него — самой панели) и `data-placement`, и
+ * считается он так же, пока панель на экране: у закрытой точка только
+ * запоминается. Своего у точки три вещи: панель `fixed` — точка стоит в окне,
+ * как якорь в `fixed`-шапке; пересчёт только на смену размера окна —
+ * прокрутка и размер чужого элемента точку не двигают, и наблюдателя якоря у
+ * неё нет; `matchWidth` не действует — ширины у точки нет. Новая точка, как
+ * новый якорь, выбирает сторону заново.
+ *
+ * Считается всё в координатах окна (`getBoundingClientRect()`), а во Frame
+ * уходит от угла блока, от которого браузер отсчитывает `left`/`top` панели
+ * (`positionOriginOf`): у `absolute` в `body` это начало документа, в
+ * позиционированном предке — его угол с прокруткой, у `fixed` — окно или
+ * предок с трансформацией. Панель внутри контейнера (`contained`) якорь не
+ * двигает: её место в контейнере решает тема, и стороны у неё нет —
+ * `data-placement` снимается.
+ *
+ * По той же причине оба наблюдателя (`ResizeObserver`) смотрят border-box:
+ * наблюдать надо ровно то, что меряем. Умолчание `content-box` пропустило бы
+ * смену одной рамки или паддинга — толщина рамки по состоянию, паддинг по
+ * размеру, — и координаты держались бы устаревшими до ближайшего
+ * scroll/resize окна.
+ */
+export declare class TAnchorPlugin extends TBasePlugin<any, TAnchorPluginEvents> {
+    /**
+     * Умолчания пропов плагина. Из них стартуют поля плагина, и их же
+     * `definePlugin` кладёт в декларации пропов: значение живёт в одном месте.
+     * `flip: true` в приватном поле адаптер не увидел бы и отдал бы Frame без
+     * `anchor_flip` своё `false`.
+     *
+     * `anchor: null` — «панель ни к чему не привязана». Якорь не опция, его
+     * задаёт только разметка, но умолчание объявлено и ему: снятый из разметки
+     * проп связка возвращает к умолчанию декларации, и без него панель
+     * оставалась бы привязанной к прежнему элементу. Так же `point: null` —
+     * «точки нет, панель у якоря».
+     */
+    static defaultValues: TDefaultValues<IAnchorPluginProps, 'anchor' | 'point' | 'placement' | 'matchWidth' | 'flip' | 'offset'>;
+    private _frame;
+    private _element;
+    /** Якорю нужны только `getBoundingClientRect()` и `parentElement` — хватает `Element`. */
+    private _anchor;
+    /** Точка в координатах окна — главнее якоря, пока задана. */
+    private _point;
+    private _placement;
+    private _matchWidth;
+    private _flip;
+    private _offset;
+    private _cleanups;
+    private _panelObserver;
+    /**
+     * Кадр, в котором вернётся наблюдение панели, снятое на уведомление якоря
+     * (см. `_onAnchorResize`); `null` — возвращать нечего.
+     */
+    private _panelResumeFrame;
+    /** Сторона, реально отданная во Frame — по ней решаем, менялся ли `data-placement`. */
+    private _actualPlacement;
+    /**
+     * Сторона, которую держит панель (см. `_holdSide`); `null` — держать
+     * нечего, и сторону выбирает `_chooseSide`. Она всегда на оси выбора
+     * потребителя: смена `placement` память забывает.
+     *
+     * Запоминает её только расчёт с разложенной панелью — высотой больше нуля.
+     * На `show` закрытая панель ещё не разложена (`display: none`), а нулевой
+     * размер влезает с любой стороны: запомненная по нему сторона держалась бы
+     * на первом настоящем измерении вместо выбора. Поэтому `_actualPlacement`
+     * памятью не служит — его пишет любой расчёт. Признак раскладки — высота и
+     * у боковой панели, которой место меряют по ширине: ширину при
+     * `matchWidth` даёт якорь и до раскладки, а высоту знает только узел.
+     */
+    private _heldSide;
+    /**
+     * Слежение идёт: панель показана или ещё гаснет (см. описание класса). Вне
+     * слежения у плагина нет подписок на якорь, и место он не считает.
+     */
+    private _following;
+    /** Отмена ожидания конца перехода закрытия; `null` — плагин не ждёт. */
+    private _stopWaiting;
+    install(ctx: IPluginContext, options?: IAnchorPluginOptions): void;
+    /**
+     * Назначает якорь. У закрытой панели якорь только запоминается: место
+     * посчитает показ.
+     */
+    setAnchor(element: Element): void;
+    removeAnchor(): void;
+    get anchor(): Element | null;
+    /**
+     * Точка в координатах окна, у которой встаёт панель, — главнее якоря,
+     * пока задана (см. описание класса). Значение: сверяется по координатам, и
+     * та же точка ничего не пересчитывает. У закрытой панели только
+     * запоминается, как якорь.
+     */
+    get point(): TPoint | null;
+    set point(value: TPoint | null);
+    get placement(): TFramePlacement;
+    set placement(value: TFramePlacement);
+    get matchWidth(): boolean;
+    set matchWidth(value: boolean);
+    get flip(): boolean;
+    set flip(value: boolean);
+    get offset(): number;
+    set offset(value: number);
+    destroy(): void;
+    /**
+     * Место панели сменилось — якорь или точка. Сторону следующий расчёт
+     * выбирает заново: прошлую выбрали у другого места. Места не осталось —
+     * панель ни к чему не привязана: подписок нет, и стороны, которую видит
+     * тема, тоже. У закрытой панели место только запоминается — посчитает его
+     * показ, — у показанной `position`, подписки и координаты — по новому
+     * месту.
+     */
+    private _onPlaceChange;
+    /**
+     * Прямоугольник места панели в координатах окна: у точки — нулевого
+     * размера, иначе якоря. Нет ни того, ни другого — `null`.
+     */
+    private _placeRect;
+    /**
+     * Письмо справа налево — у якоря, а у точки без якоря — у самой панели:
+     * начало у точки там же, откуда идёт строка вокруг неё.
+     */
+    private get _rtl();
+    /**
+     * Тянуть ширину панели есть по чему, только пока место — якорь: ширины у
+     * точки нет, и `matchWidth` с ней панель не сжимает.
+     */
+    private get _matchesWidth();
+    /**
+     * Считает координаты и кладёт их во Frame.
+     *
+     * Вне слежения не считает ничего, на какой бы стороне ни стояла панель:
+     * закрытой панели место не нужно, его посчитает показ (см. описание
+     * класса).
+     *
+     * Расчёт выбирает сторона после flip. Над якорем и под ним `x` идёт от
+     * выравнивания по строке (`_resolveX`), а `y` — от стороны. Сбоку наоборот:
+     * `x` — от стороны (`_inlineX`), `y` — от выравнивания по вертикали
+     * (`_inlineY`). Место — якорь или точка (`_placeRect`).
+     *
+     * При `matchWidth` ширину панели для `x` и shift даёт якорь (см.
+     * `_panelSize`), а не записанный во Frame `width`: до DOM он доедет только
+     * после рендера адаптера.
+     */
+    private _update;
+    /**
+     * `position` панели: `fixed` у точки и у якоря, который стоит в окне, иначе
+     * `absolute` (см. описание класса). Точка — в координатах окна и стоит в
+     * нём, как якорь в `fixed`-шапке.
+     *
+     * Выбранное держится до следующего показа или смены места. Стили предков
+     * якоря на каждом `scroll` не перечитываем: шапка, которая стала `fixed`
+     * при открытой панели, — редкость, а обход предков со стилями на каждом
+     * кадре прокрутки обошёлся бы всем.
+     */
+    private _choosePosition;
+    /**
+     * Выравнивание из выбора потребителя — конец значения: суффикс `-start` или
+     * `-end`, а значение без суффикса (`top`, `bottom`, `start`, `end`) — центр.
+     * Суффикс — с дефисом: значение `start` — сторона с центром, а не
+     * выравнивание по началу.
+     */
+    private get _alignment();
+    /**
+     * Размер видимой области — граница и для flip, и для shift.
+     *
+     * Берём `window.visualViewport`: он знает область без классической полосы
+     * прокрутки, а `innerWidth`/`innerHeight` считают полосу своей, и панель у
+     * самого края окна уезжала под неё полоской примерно в 15px. Тот же выбор
+     * границы у Floating UI для стратегии `fixed`, на которой только и работает
+     * привязка.
+     *
+     * Объекта нет (jsdom, старые браузеры) — остаётся окно.
+     * `document.documentElement.clientWidth` не берём: в jsdom он нулевой, и
+     * юнит-тесты панелей пришлось бы подпирать.
+     *
+     * Смещение видимой области при pinch-zoom (`offsetLeft`/`offsetTop`) не
+     * учитываем — координаты панели отсчитываются от окна. Это осознанная
+     * граница, а не недоделка: сдвинутую лупой область пришлось бы учитывать и
+     * в `y`, и в подписке на её собственные scroll/resize.
+     */
+    private get _viewport();
+    /**
+     * Сторона с учётом flip — на оси выбора потребителя.
+     *
+     * Выбор потребителя в `_placement` не перетирается — flip живёт только
+     * здесь, в вычислении фактической стороны. С выключенным `flip` сторона
+     * потребителя отдаётся сразу, и память не участвует. Иначе панель держит
+     * запомненную сторону (`_holdSide`), а пока держать нечего, сторону
+     * выбирает правило (`_chooseSide`). Запоминает её только расчёт с
+     * разложенной панелью (см. `_heldSide`).
+     *
+     * Правило у обеих осей одно, разная только мера: над якорем и под ним
+     * панели нужна её высота, сбоку — ширина, и там и там с отступом от якоря.
+     */
+    private _resolveSide;
+    /**
+     * Сторона из выбора потребителя. Её называет начало значения, а не
+     * префикс с дефисом: у центра суффикса нет, и `top` по префиксу `top-`
+     * уехал бы вниз.
+     */
+    private get _wantedSide();
+    /**
+     * Выбор стороны — у панели, которая стороны ещё не держит.
+     *
+     * Сторона потребителя, а если на ней панель не влезает в видимую область,
+     * а на противоположной места больше, — противоположная. Не влезает
+     * нигде — остаёмся на стороне потребителя.
+     */
+    private _chooseSide;
+    /**
+     * Удержание стороны: панель стоит на ней, пока там влезает. Не влезла —
+     * переходит на противоположную, только если влезает там; не влезает
+     * нигде — остаётся.
+     *
+     * Правило выбора для этого не годится: граница у него одна — «на стороне
+     * потребителя влезает», а когда не влезает нигде, — середина экрана, — и
+     * поле, которое стоит на ней, переводило бы панель туда и обратно на
+     * каждом пикселе прокрутки. У удержания границы две — «здесь перестала
+     * влезать» и «там влезает», — и между ними панель стоит, где стоит. Запас
+     * между границами — не подобранное число пикселей, а вся полоса, где
+     * панель влезает с обеих сторон или ни с одной.
+     */
+    private _holdSide;
+    /**
+     * Место в видимой области с этой стороны якоря: над ним (`top`) и под ним
+     * (`bottom`) — по высоте, у начала и конца строки (`start`, `end`) — по
+     * ширине, слева или справа по направлению письма.
+     */
+    private _spaceAt;
+    /**
+     * Левый край панели над якорем или под ним — с учётом выравнивания, RTL и
+     * shift.
+     *
+     * После выравнивания (`_alignX`) `x` сдвигается внутрь видимой области по
+     * горизонтали, чтобы панель не вылезала ни слева, ни справа — если панель
+     * шире области, прижимается к левому краю. Центр сдвигается так же, как
+     * начало и конец: у края окна панель перестаёт стоять по центру якоря, но
+     * остаётся видна целиком.
+     */
+    private _resolveX;
+    /**
+     * Левый край панели по выравниванию, до shift.
+     *
+     * Центр — середина якоря минус половина панели, от направления он не
+     * зависит. Начало и конец логические: в LTR `start` — левый край якоря,
+     * `end` — правый, в RTL наоборот.
+     */
+    private _alignX;
+    /**
+     * Левый край боковой панели: слева от якоря или справа по стороне и
+     * направлению письма, с зазором `offset`, — и прижатый к видимой области.
+     *
+     * Прижим по `x` у боковой панели — сверх shift: не влезла ни с одной
+     * стороны, и flip её не спас, — накрывает якорь, но видна целиком (см.
+     * описание класса). Шире области — прижимается к левому краю, как панель
+     * над якорем и под ним.
+     */
+    private _inlineX;
+    /**
+     * Верхний край боковой панели по выравниванию — и shift: `y` сдвигается
+     * внутрь видимой области по вертикали, чтобы панель не вылезала ни сверху,
+     * ни снизу; выше области — прижимается к верхнему краю.
+     */
+    private _inlineY;
+    /**
+     * Верхний край боковой панели по выравниванию, до shift: `start` — верхние
+     * края панели и якоря вровень, `end` — нижние, центр — середина к
+     * середине. Ось вертикальная, и от направления письма выравнивание не
+     * зависит.
+     */
+    private _alignY;
+    /** Пишет фактическую сторону во Frame, только если она изменилась. */
+    private _applyPlacement;
+    /**
+     * Размер панели. Нужен для выравнивания по правому краю и по центру, для
+     * показа сверху и слева, для flip и для shift — везде координата
+     * отсчитывается от размера панели, а не только от якоря.
+     *
+     * Берём `getBoundingClientRect()`, а не `offsetWidth`/`offsetHeight`:
+     * оба нулевые, пока `v-show` держит панель на `display: none`, но
+     * `getBoundingClientRect()` пересчитывается уже на первом кадре после
+     * того, как её сняли — раньше на это полагаться было нельзя, теперь за
+     * этим кадром следит `ResizeObserver`.
+     *
+     * При `matchWidth` ширина берётся из якоря, а не из DOM: во Frame она уже
+     * записана, но узел получит её только после рендера адаптера, а панели ещё
+     * может не быть вовсе. Поэтому список под полем не зависит от того,
+     * отрисовалась ли панель, и с `*-end` не мигает по устаревшей ширине.
+     * Высоту якорь не знает — она всегда из DOM.
+     */
+    private _panelSize;
+    /**
+     * Заводит слежение: показ Frame, у Frame, созданного видимым, —
+     * назначение якоря (см. описание класса). Ожидание конца закрытия
+     * отменяется: панель снова открыта.
+     */
+    private _follow;
+    /** Снимает слежение сразу — вместе с ожиданием конца закрытия, если оно шло. */
+    private _unfollow;
+    /**
+     * Закрытие снимает слежение, когда корень доиграет переходы закрытия:
+     * гаснущая и уходящая жестом панель ещё на экране и идёт за полем до
+     * конца. Снятое прямо на `hide`, слежение оставило бы её стоять, пока поле
+     * уезжает. Корня нет — ждать нечего, и слежение снимается сразу.
+     */
+    private _unfollowAfterTransitions;
+    /** Отменяет ожидание конца закрытия. */
+    private _stopWaitingTransitions;
+    /**
+     * Следит за тем, что двигает место панели.
+     *
+     * У якоря — скролл его предков, ресайз окна и изменение размера самого
+     * якоря (без скролла — например, у него пропал соседний тег). Scroll и
+     * resize пересчитывают координаты сразу, уведомление наблюдателя якоря —
+     * через `_onAnchorResize`. Каждый слушатель снимается по своей ссылке на
+     * элемент: одна переменная цикла, захваченная всеми замыканиями, к моменту
+     * очистки была бы уже `null`, и слушатели остались бы висеть.
+     *
+     * У точки — только ресайз окна: точка в координатах окна, прокрутка и
+     * размер чужого элемента её не двигают, а у края окна по-другому решаются
+     * flip и shift. Якорь, оставшийся под точкой, не наблюдается: точка
+     * главнее.
+     *
+     * Подписки живут только при слежении (`_follow`, смена места у показанной
+     * панели): у закрытой панели их нет вовсе. Прежние снимаются первыми, и
+     * повторный показ второго набора не заводит.
+     */
+    private _subscribe;
+    /** Слушатель окна — с отпиской в общем списке подписок. */
+    private _listenWindow;
+    private _unsubscribe;
+    /**
+     * Пересчёт по уведомлению наблюдателя якоря — с паузой в наблюдении панели.
+     *
+     * Колбэк `ResizeObserver` выполняется внутри шага наблюдения кадра, и
+     * записанные здесь `x`, `y` и `width` адаптер успевает отрисовать тут же, в
+     * микрозадаче после колбэка. При `matchWidth` от этого в том же шаге
+     * меняется размер панели. Панель телепортирована и в DOM лежит мельче
+     * якоря, а после уведомления якоря браузер в этом шаге доставляет только
+     * уведомления узлов глубже него. Уведомление панели пропускается: на
+     * `window` уходит `error` («ResizeObserver loop completed with undelivered
+     * notifications»), который получают трекеры ошибок у потребителя, а позиция
+     * по новому размеру панели запаздывает на кадр.
+     *
+     * Поэтому наблюдение панели снимается до пересчёта и возвращается следующим
+     * кадром — приём `autoUpdate` из Floating UI. Вернувшееся наблюдение само
+     * присылает текущий размер: если от новой ширины выросла высота (перенос
+     * текста у панели сверху), `y` поправится по нему. Возвращать микрозадачей
+     * нельзя: она попадёт в тот же шаг, и уведомление снова пропустится.
+     *
+     * Пауза только у якоря. Колбэк панели ничего не приостанавливает:
+     * `observe()` сразу присылает уведомление, и пауза на нём зациклилась бы.
+     * Scroll и resize окна, сеттеры и `show` выполняются вне шага наблюдения, им
+     * пауза не нужна.
+     */
+    private _onAnchorResize;
+    /**
+     * Снимает наблюдение панели до следующего кадра.
+     *
+     * Возврат один: повторное уведомление до кадра второго не заводит, иначе
+     * отмена застала бы только последний. Отменяют возврат `removed`, новый
+     * `ready` и `destroy` — то, что убирает или меняет саму панель. Снятие якоря
+     * и конец закрытия (`removeAnchor`, `_unsubscribe`) его не отменяют: панель
+     * осталась, и без возврата за её размером никто бы не следил.
+     */
+    private _pausePanel;
+    /** Отменяет отложенный возврат наблюдения панели. */
+    private _cancelPanelResume;
+}