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

package/dist/custom/overlay/modal-layout/modal-layout.plugin.js

@@ -0,0 +1,119 @@
+import { TBasePlugin } from "../../../base/base.class.js";
+import { toCssValue } from "../../../utils/toCssValue.js";
+//#region src/custom/overlay/modal-layout/modal-layout.plugin.ts
+/**
+* Одни ли и те же стили: те же ключи с теми же значениями. Порядок ключей не
+* важен — это набор свойств, а не список.
+*/
+function sameStyles(a, b) {
+	const keys = Object.keys(a);
+	return keys.length === Object.keys(b).length && keys.every((key) => b[key] === a[key]);
+}
+/**
+* Раскладка модального слоя — общая часть окна и выезжающей панели: слой и
+* размер в объекты стилей для разметки.
+*
+* Модальный слой ничего не меряет и координат не считает: место, край,
+* разворот и анимацию раскладывает тема по модификаторам и `data-*`. Плагину
+* остаются значения, которые в класс не уложить:
+*
+* - `styles` — панели: `z-index` слоя, размер и свои переменные наследника
+*   (`_panelVariables`: у окна — отступы от краёв экрана). Переменными, а не
+*   инлайном `width` и `height`: инлайн перебил бы тему, а у неё потолок
+*   размера по экрану и развёрнутое окно. Незаданный размер переменной не
+*   даёт вовсе — тогда действует умолчание темы (`var(--so-dialog-width, …)`);
+* - `backdropStyles` — подложке: тот же `z-index`. Подложка стоит в DOM
+*   раньше панели, и панель рисуется поверх неё просто порядком.
+*
+* Имена переменных у каждого компонента свои — их читает CSS его блока
+* (`--so-dialog-width`, `--so-drawer-width`), — поэтому база абстрактна: наследник
+* называет их (`_variables`), а считает всё база. Второй копии расчёта у
+* окна и панели нет.
+*
+* Считает при установке и на смену ширины, высоты и слоя; на смену своих
+* значений наследник зовёт тот же пересчёт (`_updateStyles`). Объекты
+* заменяются целиком, а не мутируются: геттер отдаёт ссылку наружу, и без
+* смены идентичности адаптер не увидит изменения. `change:styles` — только
+* когда стили сменились по содержимому: повод пересчёта не всегда их меняет.
+*
+* Дженерик по карте событий — для наследника со своими событиями
+* (`offset:before` у окна); свои события база шлёт через `_sink`.
+*/
+var TModalLayoutPlugin = class extends TBasePlugin {
+	_styles = {};
+	_backdropStyles = {};
+	_owner = null;
+	install(ctx) {
+		super.install(ctx);
+		const owner = ctx.getInstance();
+		if (!owner) return;
+		this._owner = owner;
+		const updateStyles = () => this._updateStyles();
+		this._listenTo(owner.events, "change:width", updateStyles);
+		this._listenTo(owner.events, "change:height", updateStyles);
+		this._listenTo(owner.events, "change:zIndex", updateStyles);
+		this._listenTo(owner.events, "change:zIndex", () => this._updateBackdropStyles());
+		this._updateStyles();
+		this._updateBackdropStyles();
+	}
+	/** Стили панели: `z-index` слоя, переменные размера и свои переменные наследника. */
+	get styles() {
+		return this._styles;
+	}
+	/** Стили подложки: тот же `z-index`, что у панели. */
+	get backdropStyles() {
+		return this._backdropStyles;
+	}
+	destroy() {
+		this._owner = null;
+		super.destroy();
+	}
+	/**
+	* Эмит собственных событий раскладки — без приведения `this.events` к
+	* конкретной карте (см. `TEventSink` в `@soxa-ui/core`): карта — дженерик,
+	* а `change:styles` и `change:backdropStyles` объявлены здесь.
+	*/
+	get _sink() {
+		return this.events;
+	}
+	/**
+	* Свои переменные панели сверх размера: имя переменной → CSS-значение.
+	* Их читает каждый пересчёт стилей, начиная с установки, поэтому то, из
+	* чего они строятся, наследник обязан знать уже тогда. По умолчанию своих
+	* нет.
+	*/
+	_panelVariables() {
+		return {};
+	}
+	/**
+	* Пересчитать стили панели. Наследник зовёт его на смену значений, из
+	* которых строит `_panelVariables`.
+	*/
+	_updateStyles() {
+		const oldStyles = this.styles;
+		const owner = this._owner;
+		if (!owner) return;
+		const styles = { "z-index": owner.zIndex };
+		if (owner.width !== void 0) styles[this._variables.width] = toCssValue(owner.width);
+		if (owner.height !== void 0) styles[this._variables.height] = toCssValue(owner.height);
+		Object.assign(styles, this._panelVariables());
+		if (sameStyles(styles, this._styles)) return;
+		this._styles = styles;
+		this._sink.emit("change:styles", {
+			newValue: this._styles,
+			oldValue: oldStyles
+		});
+	}
+	_updateBackdropStyles() {
+		const oldBackdropStyles = this.backdropStyles;
+		const owner = this._owner;
+		if (!owner) return;
+		this._backdropStyles = { "z-index": owner.zIndex };
+		this._sink.emit("change:backdropStyles", {
+			newValue: this._backdropStyles,
+			oldValue: oldBackdropStyles
+		});
+	}
+};
+//#endregion
+export { TModalLayoutPlugin };

package/dist/custom/overlay/modal-layout/types.d.ts

@@ -0,0 +1,13 @@
+import type { TValuePayload } from '@soxa-ui/core';
+import type { TPluginEvents } from '../../../base';
+export type TModalLayoutPluginEvents = TPluginEvents & {
+    'change:styles': (payload: TValuePayload<Record<string, string | number>>) => void;
+    'change:backdropStyles': (payload: TValuePayload<Record<string, string | number>>) => void;
+};
+/** Имена переменных размера панели: их читает CSS блока компонента. */
+export type TModalLayoutVariables = {
+    /** Переменная ширины — `--so-dialog-width` у окна */
+    readonly width: string;
+    /** Переменная высоты — `--so-dialog-height` у окна */
+    readonly height: string;
+};

package/dist/custom/overlay/modal-names/index.d.ts

@@ -0,0 +1 @@
+export * from './modal-names.plugin';

package/dist/custom/overlay/modal-names/modal-names.plugin.d.ts

@@ -0,0 +1,14 @@
+import type { IModalLayer } from '@soxa-ui/core';
+import { TNamesPlugin } from '../../../locale/names.plugin';
+import type { TTranslations } from '../../../locale/types';
+/**
+ * TModalNamesPlugin — имя кнопки закрытия модального слоя от локали: в
+ * `closeAria`.
+ *
+ * Ставится наследникам слоя — выезжающей панели и, через
+ * `TDialogNamesPlugin`, окну, — как плагины связок: у каждого свой.
+ * Дженерик по владельцу — для наследника, у которого кнопок больше.
+ */
+export declare class TModalNamesPlugin<TOwner extends IModalLayer<any, any> = IModalLayer> extends TNamesPlugin<TOwner> {
+    protected _name(owner: TOwner, translations: TTranslations): void;
+}

package/dist/custom/overlay/modal-names/modal-names.plugin.js

@@ -0,0 +1,17 @@
+import { TNamesPlugin } from "../../../locale/names.plugin.js";
+//#region src/custom/overlay/modal-names/modal-names.plugin.ts
+/**
+* TModalNamesPlugin — имя кнопки закрытия модального слоя от локали: в
+* `closeAria`.
+*
+* Ставится наследникам слоя — выезжающей панели и, через
+* `TDialogNamesPlugin`, окну, — как плагины связок: у каждого свой.
+* Дженерик по владельцу — для наследника, у которого кнопок больше.
+*/
+var TModalNamesPlugin = class extends TNamesPlugin {
+	_name(owner, translations) {
+		owner.closeAria.add("aria-label", translations.modal.close);
+	}
+};
+//#endregion
+export { TModalNamesPlugin };

package/dist/custom/overlay/open-state.d.ts

@@ -0,0 +1,12 @@
+import type { IPluginContext } from '../../base';
+import type { IOverlayOpenOptions, IOverlayOpenState } from './types';
+/**
+ * Binds overlay behavior to its owner's openness and visibility. A hidden
+ * owner keeps its open state, but dismiss, focus and scroll behavior pause
+ * until it is shown again. Owners without a visible property remain supported.
+ *
+ * User dismissal goes through requestClose when available; programmatic writes
+ * still target the configured property. Each binding removes only its own
+ * subscriptions when the plugin is destroyed.
+ */
+export declare function bindOverlayOpen(ctx: IPluginContext, options: IOverlayOpenOptions | undefined, onChange: (open: boolean) => void): IOverlayOpenState | null;

package/dist/custom/overlay/open-state.js

@@ -0,0 +1,42 @@
+import { isCloseRequestable, isEventSource } from "@soxa-ui/core";
+//#region src/custom/overlay/open-state.ts
+/** Свойство открытости по умолчанию — см. `IOverlayOpenOptions.property`. */
+var DEFAULT_PROPERTY = "open";
+/**
+* Binds overlay behavior to its owner's openness and visibility. A hidden
+* owner keeps its open state, but dismiss, focus and scroll behavior pause
+* until it is shown again. Owners without a visible property remain supported.
+*
+* User dismissal goes through requestClose when available; programmatic writes
+* still target the configured property. Each binding removes only its own
+* subscriptions when the plugin is destroyed.
+*/
+function bindOverlayOpen(ctx, options, onChange) {
+	const instance = ctx.getInstance();
+	const property = options?.property === void 0 ? DEFAULT_PROPERTY : options.property;
+	if (!instance || !property || !(property in instance)) return null;
+	const read = () => !!Reflect.get(instance, property) && Reflect.get(instance, "visible") !== false;
+	const write = (value) => {
+		Reflect.set(instance, property, value);
+	};
+	const events = Reflect.get(instance, "events");
+	const source = isEventSource(events) ? events : null;
+	const event = options?.event ?? `change:${property}`;
+	const handler = () => onChange(read());
+	source?.on(event, handler);
+	if (property !== "visible") source?.on("change:visible", handler);
+	return {
+		read,
+		write,
+		close(reason) {
+			if (isCloseRequestable(instance)) instance.requestClose(reason);
+			else write(false);
+		},
+		unbind() {
+			source?.off(event, handler);
+			if (property !== "visible") source?.off("change:visible", handler);
+		}
+	};
+}
+//#endregion
+export { bindOverlayOpen };

package/dist/custom/overlay/scroll-lock/index.d.ts

@@ -0,0 +1,2 @@
+export { TScrollLockPlugin } from './scroll-lock.plugin';
+export type { IScrollLockPluginOptions, TScrollLockPluginEvents } from './types';

package/dist/custom/overlay/scroll-lock/lock.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Замок прокрутки документа со счётчиком слоёв.
+ *
+ * Слоёв поверх страницы бывает несколько — диалог, из него выезжающая
+ * панель, — и каждый запирает прокрутку сам. Считать это флагом нельзя:
+ * закрытие верхнего слоя вернуло бы прокрутку, пока нижний ещё открыт.
+ * Поэтому замок один на документ, у него счётчик, и стиль документа
+ * возвращается ровно тогда, когда его отпустил последний.
+ *
+ * Возвращаются **инлайновые** значения, которые были до замка: страница
+ * могла задать `overflow` и своими правилами, и инлайном, а вернуть надо то,
+ * что мы перебили.
+ */
+/** Запереть прокрутку документа. Первый вызов запирает, остальные считаются. */
+export declare function lockScroll(doc: Document): void;
+/** Отпустить замок. Прокрутка вернётся, когда его отпустит последний слой. */
+export declare function unlockScroll(doc: Document): void;

package/dist/custom/overlay/scroll-lock/lock.js

@@ -0,0 +1,83 @@
+//#region src/custom/overlay/scroll-lock/lock.ts
+var LOCKS = /* @__PURE__ */ new WeakMap();
+/** Запереть прокрутку документа. Первый вызов запирает, остальные считаются. */
+function lockScroll(doc) {
+	const lock = LOCKS.get(doc);
+	if (lock) {
+		lock.count += 1;
+		return;
+	}
+	LOCKS.set(doc, {
+		count: 1,
+		restore: applyLock(doc)
+	});
+}
+/** Отпустить замок. Прокрутка вернётся, когда его отпустит последний слой. */
+function unlockScroll(doc) {
+	const lock = LOCKS.get(doc);
+	if (!lock) return;
+	lock.count -= 1;
+	if (lock.count > 0) return;
+	LOCKS.delete(doc);
+	for (const entry of lock.restore) restoreStyle(entry);
+}
+/**
+* Запирает прокрутку и отдаёт то, что перебил.
+*
+* `overflow: hidden` ставится и на `html`, и на `body`: какой из них
+* прокручивает страницу, решает сама страница. По спецификации `overflow`
+* с `body` доходит до области просмотра, только пока у `html` он `visible`,
+* — а `html { overflow-y: scroll }` ставят как раз затем, чтобы страница не
+* дёргалась. Заперев только один из двух, замок молча не сработал бы.
+*/
+function applyLock(doc) {
+	const root = doc.documentElement;
+	const body = doc.body;
+	const gap = scrollbarGap(doc);
+	const restore = [takeStyle(root.style, "overflow"), takeStyle(body.style, "overflow")];
+	root.style.setProperty("overflow", "hidden");
+	body.style.setProperty("overflow", "hidden");
+	if (gap > 0) {
+		restore.push(takeStyle(body.style, "padding-inline-end"));
+		body.style.setProperty("padding-inline-end", `${paddingEnd(body) + gap}px`);
+	}
+	return restore;
+}
+/**
+* Ширина полосы прокрутки — разница между окном и областью просмотра
+* документа. Без неё страница дёргается на ширину полосы, едва прокрутку
+* заперли.
+*
+* Компенсация — `padding-inline-end`, а не `padding-right`: полоса прокрутки
+* области просмотра стоит на той стороне, куда смотрит направление корня, и
+* в RTL это левый край — ровно то, что значит `inline-end`.
+*
+* Область просмотра нулевой ширины значит, что раскладки нет вовсе:
+* компенсировать нечего.
+*/
+function scrollbarGap(doc) {
+	const view = doc.defaultView;
+	const width = doc.documentElement.clientWidth;
+	if (!view || width <= 0) return 0;
+	const gap = view.innerWidth - width;
+	return gap > 0 ? gap : 0;
+}
+/** Отступ, который уже есть у элемента, — к нему прибавляется компенсация. */
+function paddingEnd(element) {
+	const view = element.ownerDocument.defaultView;
+	const parsed = Number.parseFloat(view?.getComputedStyle(element).paddingInlineEnd ?? "");
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+function takeStyle(style, property) {
+	return {
+		style,
+		property,
+		value: style.getPropertyValue(property)
+	};
+}
+function restoreStyle({ style, property, value }) {
+	if (value === "") style.removeProperty(property);
+	else style.setProperty(property, value);
+}
+//#endregion
+export { lockScroll, unlockScroll };

package/dist/custom/overlay/scroll-lock/scroll-lock.plugin.d.ts

@@ -0,0 +1,78 @@
+import { TBasePlugin } from '../../../base';
+import type { IPluginContext } from '../../../base';
+import type { IScrollLockPluginOptions, TScrollLockPluginEvents } from './types';
+/**
+ * TScrollLockPlugin — пока владелец открыт, страница под ним не
+ * прокручивается.
+ *
+ * Модальному окну и выезжающей панели прокрутка фона мешает: пользователь
+ * тянет колесо, а уезжает то, с чем он сейчас не работает. Запирается это
+ * стилем документа, поэтому живёт в плагине: ядру DOM недоступен, а
+ * повторять связку «открыто ⇄ заперто» в шаблоне каждого из шести адаптеров
+ * значило бы поменять в одном и забыть в пяти.
+ *
+ * Открытость плагин ведёт сам — по свойству владельца (`property`, по
+ * умолчанию `open`), тем же способом, что `TDismissPlugin`. Вручную замок
+ * ведут через `enabled` при `property: null`.
+ *
+ * Слоёв поверх страницы бывает несколько, и замок у документа один на всех
+ * (см. `lock.ts`): два открытых слоя держат его вместе, закрытие одного
+ * прокрутку не возвращает. Свой счёт плагин снимает и при размонтировании
+ * корня, и в `destroy()` — иначе страница осталась бы запертой навсегда.
+ *
+ * **Закрытие отпускает замок после перехода.** Закрытая панель ещё на экране
+ * — гаснет или уезжает переходом темы, — и полоса прокрутки, вернувшись
+ * сразу, сузила бы область просмотра: окно по центру переехало бы на
+ * полширины полосы, панель у края — на всю. Поэтому, выключившись, плагин
+ * держит замок, пока корень не доиграет переходы закрытия (`afterTransitions`),
+ * и только потом отдаёт свой счёт. Открыли снова, пока он ждёт, — ожидание
+ * отменяется, а счёт остаётся прежним: замок и так лежит. Снятый корень и
+ * `destroy()` отпускают замок сразу: ждать перехода не у кого.
+ *
+ * Ждёт плагин только корень, без подложки. У модального слоя корень и есть
+ * панель, а подложка по контракту темы идёт вместе с ней и с той же
+ * длительностью. Узла подложки у плагина нет, и искать её в DOM значило бы
+ * завести второй путь к разметке слоя.
+ *
+ * Документ берётся у корня (`TElementPlugin`), а не из `globalThis`:
+ * компонент живёт и в чужом документе — в `iframe`, в окне, открытом
+ * `window.open`. Пока корня нет, запирать нечего и негде.
+ *
+ * Чего плагин не делает: прокрутку внутри самой панели он не трогает — она
+ * идёт своим `overflow` в теме. Поведение iOS Safari, где `overflow: hidden`
+ * прокрутку не держит, сюда пока не входит.
+ */
+export declare class TScrollLockPlugin extends TBasePlugin<any, TScrollLockPluginEvents> {
+    /** Умолчания опций, объявленных пропами, — см. `TDismissPlugin.defaultValues`. */
+    static defaultValues: Required<Pick<IScrollLockPluginOptions, 'enabled'>>;
+    private _open;
+    private _element;
+    private _enabled;
+    /** Документ, у которого плагин держит замок; `null` — не держит. */
+    private _locked;
+    /** Отмена ожидания конца перехода закрытия; `null` — плагин не ждёт. */
+    private _stopWaiting;
+    install(ctx: IPluginContext, options?: IScrollLockPluginOptions): void;
+    /**
+     * Запирать ли прокрутку. Владелец взводит это открытием; своё значение
+     * плагин держит и без корня — замок ляжет, как только корень объявят.
+     *
+     * `true` запирает сразу, а `false` отпускает замок не сразу, а когда корень
+     * доиграет переходы закрытия. `change:enabled` приходит сразу в обе
+     * стороны: это нужное состояние, а не факт отпирания.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    destroy(): void;
+    /**
+     * Замок сейчас — ровно по состоянию: лежит, когда владелец открыт и корень
+     * объявлен. Ожидание перехода закрытия это отменяет: состояние решено
+     * заново.
+     */
+    private _sync;
+    /**
+     * Выключили — замок остаётся, пока корень доигрывает переходы закрытия, и
+     * только потом отпускается. Замка нет — отпускать нечего.
+     */
+    private _releaseAfterTransitions;
+}

package/dist/custom/overlay/scroll-lock/scroll-lock.plugin.js

@@ -0,0 +1,134 @@
+import { TBasePlugin } from "../../../base/base.class.js";
+import { TElementPlugin } from "../../element/element.plugin.js";
+import { afterTransitions } from "../../../utils/afterTransitions.js";
+import { bindOverlayOpen } from "../open-state.js";
+import { lockScroll, unlockScroll } from "./lock.js";
+//#region src/custom/overlay/scroll-lock/scroll-lock.plugin.ts
+/**
+* TScrollLockPlugin — пока владелец открыт, страница под ним не
+* прокручивается.
+*
+* Модальному окну и выезжающей панели прокрутка фона мешает: пользователь
+* тянет колесо, а уезжает то, с чем он сейчас не работает. Запирается это
+* стилем документа, поэтому живёт в плагине: ядру DOM недоступен, а
+* повторять связку «открыто ⇄ заперто» в шаблоне каждого из шести адаптеров
+* значило бы поменять в одном и забыть в пяти.
+*
+* Открытость плагин ведёт сам — по свойству владельца (`property`, по
+* умолчанию `open`), тем же способом, что `TDismissPlugin`. Вручную замок
+* ведут через `enabled` при `property: null`.
+*
+* Слоёв поверх страницы бывает несколько, и замок у документа один на всех
+* (см. `lock.ts`): два открытых слоя держат его вместе, закрытие одного
+* прокрутку не возвращает. Свой счёт плагин снимает и при размонтировании
+* корня, и в `destroy()` — иначе страница осталась бы запертой навсегда.
+*
+* **Закрытие отпускает замок после перехода.** Закрытая панель ещё на экране
+* — гаснет или уезжает переходом темы, — и полоса прокрутки, вернувшись
+* сразу, сузила бы область просмотра: окно по центру переехало бы на
+* полширины полосы, панель у края — на всю. Поэтому, выключившись, плагин
+* держит замок, пока корень не доиграет переходы закрытия (`afterTransitions`),
+* и только потом отдаёт свой счёт. Открыли снова, пока он ждёт, — ожидание
+* отменяется, а счёт остаётся прежним: замок и так лежит. Снятый корень и
+* `destroy()` отпускают замок сразу: ждать перехода не у кого.
+*
+* Ждёт плагин только корень, без подложки. У модального слоя корень и есть
+* панель, а подложка по контракту темы идёт вместе с ней и с той же
+* длительностью. Узла подложки у плагина нет, и искать её в DOM значило бы
+* завести второй путь к разметке слоя.
+*
+* Документ берётся у корня (`TElementPlugin`), а не из `globalThis`:
+* компонент живёт и в чужом документе — в `iframe`, в окне, открытом
+* `window.open`. Пока корня нет, запирать нечего и негде.
+*
+* Чего плагин не делает: прокрутку внутри самой панели он не трогает — она
+* идёт своим `overflow` в теме. Поведение iOS Safari, где `overflow: hidden`
+* прокрутку не держит, сюда пока не входит.
+*/
+var TScrollLockPlugin = class TScrollLockPlugin extends TBasePlugin {
+	/** Умолчания опций, объявленных пропами, — см. `TDismissPlugin.defaultValues`. */
+	static defaultValues = { enabled: false };
+	_open = null;
+	_element = null;
+	_enabled = TScrollLockPlugin.defaultValues.enabled;
+	/** Документ, у которого плагин держит замок; `null` — не держит. */
+	_locked = null;
+	/** Отмена ожидания конца перехода закрытия; `null` — плагин не ждёт. */
+	_stopWaiting = null;
+	install(ctx, options) {
+		super.install(ctx, options);
+		const elementPlugin = ctx.get(TElementPlugin);
+		elementPlugin?.events.on("ready", (element) => {
+			this._element = element;
+			this._sync();
+		});
+		elementPlugin?.events.on("removed", () => {
+			this._element = null;
+			this._sync();
+		});
+		this._enabled = options?.enabled ?? this._enabled;
+		this._open = bindOverlayOpen(ctx, options, (open) => {
+			this.enabled = open;
+		});
+		if (this._open) this.enabled = this._open.read();
+		this._sync();
+	}
+	/**
+	* Запирать ли прокрутку. Владелец взводит это открытием; своё значение
+	* плагин держит и без корня — замок ляжет, как только корень объявят.
+	*
+	* `true` запирает сразу, а `false` отпускает замок не сразу, а когда корень
+	* доиграет переходы закрытия. `change:enabled` приходит сразу в обе
+	* стороны: это нужное состояние, а не факт отпирания.
+	*/
+	get enabled() {
+		return this._enabled;
+	}
+	set enabled(value) {
+		const oldEnabled = this.enabled;
+		if (this._enabled === value) return;
+		this._enabled = value;
+		if (value) this._sync();
+		else this._releaseAfterTransitions();
+		this.events.emit("change:enabled", {
+			newValue: value,
+			oldValue: oldEnabled
+		});
+	}
+	destroy() {
+		this._enabled = false;
+		this._sync();
+		this._element = null;
+		this._open?.unbind();
+		this._open = null;
+		super.destroy();
+	}
+	/**
+	* Замок сейчас — ровно по состоянию: лежит, когда владелец открыт и корень
+	* объявлен. Ожидание перехода закрытия это отменяет: состояние решено
+	* заново.
+	*/
+	_sync() {
+		this._stopWaiting?.();
+		this._stopWaiting = null;
+		const doc = this._enabled ? this._element?.ownerDocument ?? null : null;
+		if (doc === this._locked) return;
+		if (this._locked) unlockScroll(this._locked);
+		if (doc) lockScroll(doc);
+		this._locked = doc;
+	}
+	/**
+	* Выключили — замок остаётся, пока корень доигрывает переходы закрытия, и
+	* только потом отпускается. Замка нет — отпускать нечего.
+	*/
+	_releaseAfterTransitions() {
+		const element = this._element;
+		if (!this._locked || !element) return;
+		this._stopWaiting = afterTransitions(element, () => {
+			this._stopWaiting = null;
+			this._sync();
+		});
+	}
+};
+//#endregion
+export { TScrollLockPlugin };

package/dist/custom/overlay/scroll-lock/types.d.ts

@@ -0,0 +1,17 @@
+import type { TValuePayload } from '@soxa-ui/core';
+import type { TPluginEvents } from '../../../base';
+import type { IOverlayOpenOptions } from '../types';
+export interface IScrollLockPluginOptions extends IOverlayOpenOptions {
+    /**
+     * Заперта ли прокрутка сразу после установки.
+     *
+     * Обычно этого не задают: плагин сам следит за открытостью владельца
+     * (`property`). Но, как и у `TDismissPlugin`, замок можно вести и вручную
+     * — `property: null` и запись в `enabled`.
+     */
+    enabled?: boolean;
+}
+export type TScrollLockPluginEvents = TPluginEvents & {
+    /** change:enabled */
+    'change:enabled': (payload: TValuePayload<boolean>) => void;
+};

package/dist/custom/overlay/swipe/index.d.ts

@@ -0,0 +1,2 @@
+export { TSwipePlugin } from './swipe.plugin';
+export type { ISwipeOwner, TSwipePluginEvents, TSwipeAxis, TSwipeGesture, TSwipePress, TSwipeSample, } from './types';