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

package/dist/custom/collection/collection-bundles-access.plugin.d.ts

@@ -0,0 +1,29 @@
+import { TBasePlugin } from '../../base';
+import type { IPluginContext, IPluginBundle } from '../../base';
+import { TCollectionBundlesPlugin } from './bundles.plugin';
+import type { TCollectionEngine } from '@soxa-ui/core';
+/**
+ * TCollectionBundlesAccess — базовый плагин доступа к bundles элементов коллекции.
+ *
+ * Сам ничего не накапливает: накоплением bundles занимается {@link TCollectionBundlesPlugin}.
+ * Этот плагин лишь подхватывает реестр bundles в install() и предоставляет удобные
+ * accessors для обращения к бандлам по uid/item/индексу.
+ *
+ * Наследники (например, {@link TCollectionElements}) добавляют свои типизированные
+ * accessors поверх bundles.
+ */
+export declare abstract class TCollectionBundlesAccess extends TBasePlugin<any> {
+    /** Реестр bundles элементов коллекции. */
+    protected bundles: TCollectionBundlesPlugin | undefined;
+    install(ctx: IPluginContext): void;
+    /** Ссылка на коллекцию, к которой привязан реестр bundles. */
+    get engine(): TCollectionEngine<any, any> | null;
+    /** Bundle элемента по uid. */
+    protected getBundleByUid(uid: string | number): IPluginBundle | undefined;
+    /** Bundle по элементу коллекции. */
+    protected getBundleByItem(item: unknown): IPluginBundle | undefined;
+    /** Элемент коллекции по порядковому индексу. */
+    protected getItemByIndex(index: number): unknown;
+    /** Все bundles в порядке элементов коллекции. */
+    protected getBundleAll(): IPluginBundle[];
+}

package/dist/custom/collection/collection-bundles-access.plugin.js

@@ -0,0 +1,44 @@
+import { TBasePlugin } from "../../base/base.class.js";
+import { TCollectionBundlesPlugin } from "./bundles.plugin.js";
+import { batchOf } from "@soxa-ui/core";
+//#region src/custom/collection/collection-bundles-access.plugin.ts
+/**
+* TCollectionBundlesAccess — базовый плагин доступа к bundles элементов коллекции.
+*
+* Сам ничего не накапливает: накоплением bundles занимается {@link TCollectionBundlesPlugin}.
+* Этот плагин лишь подхватывает реестр bundles в install() и предоставляет удобные
+* accessors для обращения к бандлам по uid/item/индексу.
+*
+* Наследники (например, {@link TCollectionElements}) добавляют свои типизированные
+* accessors поверх bundles.
+*/
+var TCollectionBundlesAccess = class extends TBasePlugin {
+	/** Реестр bundles элементов коллекции. */
+	bundles;
+	install(ctx) {
+		super.install(ctx);
+		this.bundles = ctx.get(TCollectionBundlesPlugin);
+	}
+	/** Ссылка на коллекцию, к которой привязан реестр bundles. */
+	get engine() {
+		return this.bundles?.engine ?? null;
+	}
+	/** Bundle элемента по uid. */
+	getBundleByUid(uid) {
+		return this.bundles?.getByUid(uid);
+	}
+	/** Bundle по элементу коллекции. */
+	getBundleByItem(item) {
+		return this.bundles?.getByItem(item);
+	}
+	/** Элемент коллекции по порядковому индексу. */
+	getItemByIndex(index) {
+		return batchOf(this.bundles?.engine)?.items[index];
+	}
+	/** Все bundles в порядке элементов коллекции. */
+	getBundleAll() {
+		return this.bundles?.getAll() ?? [];
+	}
+};
+//#endregion
+export { TCollectionBundlesAccess };

package/dist/custom/collection/collection-elements.plugin.d.ts

@@ -0,0 +1,55 @@
+import { TCollectionBundlesAccess } from './collection-bundles-access.plugin';
+/**
+ * TCollectionElements — быстрый доступ к DOM-элементам элементов коллекции.
+ *
+ * Не хранит элементы: извлекает их на лету из bundle каждого item'а через
+ * {@link TElementPlugin}. Сами элементы лежат в bundles (реестр
+ * {@link TCollectionBundlesPlugin}), инстансы — в engine.
+ *
+ * Узлы отдаются как `Element` — ровно тем типом, каким их держит
+ * {@link TElementPlugin}. Кому нужна HTML-специфика, сужает узел гардом из
+ * `utils`; отфильтровать не-HTML узлы здесь нельзя — пропавший элемент
+ * коллекции хуже ошибки типа.
+ *
+ * Узла, которого ещё нет в документе, ждут здесь же — {@link waitFor}.
+ *
+ * Зависит от TCollectionBundlesPlugin (регистрируется в том же bundle).
+ */
+export declare class TCollectionElements extends TCollectionBundlesAccess {
+    /**
+     * Ждать узел элемента коллекции, которого в документе ещё нет: модель уже
+     * сменилась — новый месяц календаря, новый таб, — а разметка его ещё не
+     * нарисовала.
+     *
+     * Узел приходит в два шага: элемент входит в коллекцию — его набор
+     * регистрируется в реестре (`bundle:registered`), — и узел объявляет его
+     * `TElementPlugin` (`ready`, кадром позже привязки). Порядок шагов решает
+     * адаптер: обычно регистрация идёт раньше привязки узла, но бывает и после
+     * принятия компонента, когда узел уже привязан и его `ready` пришло раньше
+     * регистрации. Поэтому проверка зовётся на каждой регистрации сразу и ещё
+     * раз — на `ready` узла этого элемента.
+     *
+     * Какой узел нужен, помощник не знает: это решает проверка, и цель она
+     * ищет заново на каждый вызов — у модели, а не запомненную заранее. `true`
+     * — дождались: помощник снимает свои подписки. Подписки — прямые: шина
+     * реестра живёт в том же наборе, а шина узла умирает вместе с набором
+     * элемента. Первую попытку, до ожидания, делает тот, кто ждёт: помощник
+     * проверку сам не зовёт.
+     *
+     * @param check проверка: нашёлся ли узел и сделано ли с ним то, ради чего
+     * его ждали. `true` — ожидание кончено.
+     * @returns снять ожидание; повторный вызов и вызов после `true` ничего не
+     * делают.
+     */
+    waitFor(check: () => boolean): () => void;
+    /** DOM-элемент элемента коллекции по uid. */
+    getElementByUid(uid: string | number): Element | null;
+    /** DOM-элемент по элементу коллекции. */
+    getElementByItem(item: unknown): Element | null;
+    /** DOM-элемент по порядковому индексу в коллекции. */
+    getElementByIndex(index: number): Element | null;
+    /** Все DOM-элементы в порядке элементов коллекции. */
+    getAll(): Element[];
+    /** Найти uid по DOM-элементу. */
+    getUidByElement(element: Element): string | number | undefined;
+}

package/dist/custom/collection/collection-elements.plugin.js

@@ -0,0 +1,100 @@
+import { TCollectionBundlesAccess } from "./collection-bundles-access.plugin.js";
+import { TElementPlugin } from "../element/element.plugin.js";
+import { batchOf } from "@soxa-ui/core";
+//#region src/custom/collection/collection-elements.plugin.ts
+/**
+* TCollectionElements — быстрый доступ к DOM-элементам элементов коллекции.
+*
+* Не хранит элементы: извлекает их на лету из bundle каждого item'а через
+* {@link TElementPlugin}. Сами элементы лежат в bundles (реестр
+* {@link TCollectionBundlesPlugin}), инстансы — в engine.
+*
+* Узлы отдаются как `Element` — ровно тем типом, каким их держит
+* {@link TElementPlugin}. Кому нужна HTML-специфика, сужает узел гардом из
+* `utils`; отфильтровать не-HTML узлы здесь нельзя — пропавший элемент
+* коллекции хуже ошибки типа.
+*
+* Узла, которого ещё нет в документе, ждут здесь же — {@link waitFor}.
+*
+* Зависит от TCollectionBundlesPlugin (регистрируется в том же bundle).
+*/
+var TCollectionElements = class extends TCollectionBundlesAccess {
+	/**
+	* Ждать узел элемента коллекции, которого в документе ещё нет: модель уже
+	* сменилась — новый месяц календаря, новый таб, — а разметка его ещё не
+	* нарисовала.
+	*
+	* Узел приходит в два шага: элемент входит в коллекцию — его набор
+	* регистрируется в реестре (`bundle:registered`), — и узел объявляет его
+	* `TElementPlugin` (`ready`, кадром позже привязки). Порядок шагов решает
+	* адаптер: обычно регистрация идёт раньше привязки узла, но бывает и после
+	* принятия компонента, когда узел уже привязан и его `ready` пришло раньше
+	* регистрации. Поэтому проверка зовётся на каждой регистрации сразу и ещё
+	* раз — на `ready` узла этого элемента.
+	*
+	* Какой узел нужен, помощник не знает: это решает проверка, и цель она
+	* ищет заново на каждый вызов — у модели, а не запомненную заранее. `true`
+	* — дождались: помощник снимает свои подписки. Подписки — прямые: шина
+	* реестра живёт в том же наборе, а шина узла умирает вместе с набором
+	* элемента. Первую попытку, до ожидания, делает тот, кто ждёт: помощник
+	* проверку сам не зовёт.
+	*
+	* @param check проверка: нашёлся ли узел и сделано ли с ним то, ради чего
+	* его ждали. `true` — ожидание кончено.
+	* @returns снять ожидание; повторный вызов и вызов после `true` ничего не
+	* делают.
+	*/
+	waitFor(check) {
+		const bundles = this.bundles;
+		const unsubscribes = [];
+		let waiting = true;
+		const stop = () => {
+			if (!waiting) return;
+			waiting = false;
+			for (const unsubscribe of unsubscribes.splice(0)) unsubscribe();
+		};
+		const test = () => {
+			if (waiting && check()) stop();
+		};
+		const onRegistered = ({ bundle }) => {
+			test();
+			const element = bundle.get(TElementPlugin);
+			if (!waiting || !element) return;
+			element.events.on("ready", test);
+			unsubscribes.push(() => element.events.off("ready", test));
+		};
+		if (bundles) {
+			bundles.events.on("bundle:registered", onRegistered);
+			unsubscribes.push(() => bundles.events.off("bundle:registered", onRegistered));
+		}
+		return stop;
+	}
+	/** DOM-элемент элемента коллекции по uid. */
+	getElementByUid(uid) {
+		return this.getBundleByUid(uid)?.get(TElementPlugin)?.element ?? null;
+	}
+	/** DOM-элемент по элементу коллекции. */
+	getElementByItem(item) {
+		return this.getBundleByItem(item)?.get(TElementPlugin)?.element ?? null;
+	}
+	/** DOM-элемент по порядковому индексу в коллекции. */
+	getElementByIndex(index) {
+		const item = this.getItemByIndex(index);
+		return item === void 0 ? null : this.getElementByItem(item);
+	}
+	/** Все DOM-элементы в порядке элементов коллекции. */
+	getAll() {
+		const result = [];
+		for (const bundle of this.getBundleAll()) {
+			const element = bundle.get(TElementPlugin)?.element;
+			if (element) result.push(element);
+		}
+		return result;
+	}
+	/** Найти uid по DOM-элементу. */
+	getUidByElement(element) {
+		for (const item of batchOf(this.bundles?.engine)?.items ?? []) if (this.getElementByItem(item) === element) return item.uid;
+	}
+};
+//#endregion
+export { TCollectionElements };

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

@@ -0,0 +1,4 @@
+export { TCollectionBundlesPlugin } from './bundles.plugin';
+export type { TBundlesEvents } from './types';
+export { TCollectionBundlesAccess } from './collection-bundles-access.plugin';
+export { TCollectionElements } from './collection-elements.plugin';

package/dist/custom/collection/leaving-focus.d.ts

@@ -0,0 +1,119 @@
+import type { IPlainExtension } from '@soxa-ui/core';
+import type { TCollectionElements } from './collection-elements.plugin';
+/**
+ * Что решает плагин: где корень, что запомнить о месте элемента и куда отдать
+ * фокус.
+ */
+export type TLeavingFocusHost<TItem, TPlace> = {
+    /**
+     * Узел корня владельца. `null` — узла нет, и фокус не читается: закрыть
+     * элемент из кода можно и на сервере, где документа нет.
+     */
+    readonly root: () => Element | null;
+    /**
+     * Что о месте элемента известно только до его удаления, кроме узла: у
+     * тега — соседи. Зовётся, когда фокус оказался в узле уходящего элемента.
+     */
+    readonly place: (item: TItem) => TPlace;
+    /**
+     * Отдать фокус: элемент закрыли, он ушёл, а фокус — в его узле или потерян
+     * вместе с ним.
+     */
+    readonly pass: (root: Element, place: TPlace) => void;
+};
+/**
+ * Фокус уходящего элемента коллекции — элемента, который закрыли: клавишей,
+ * крестиком, из кода. Узел элемента уходит из документа, и фокус, стоявший в
+ * нём, ушёл бы на страницу: следующий Tab начинал бы обход заново.
+ *
+ * Правило одно на коллекции с закрытием — Tags и Tabs, поэтому ожидание —
+ * модуль, а не копия в каждом плагине. Плагин слушает закрытие своего
+ * расширения и решает, что запомнить о месте элемента и куда отдать фокус
+ * (`host`), а когда переносить фокус и переносить ли вообще — помощник.
+ *
+ * Фокус переходит, когда сошлись два факта: элемент закрыли (`close` — плагин
+ * зовёт его из `item:close` своего расширения) и элемент ушёл из коллекции
+ * (`change:items` у `plain`), — вторым из них. Порядок у фактов разный:
+ * обычно элемент удаляет само закрытие, следом за `item:close`, но подписчик
+ * закрытия, стоящий раньше плагина, снимает его ещё в своём обработчике —
+ * так поле Select снимает выбор с опции, а приложение может удалить таб из
+ * своего обработчика события фасада, — и элемент уходит раньше, чем закрытие
+ * дойдёт до плагина.
+ *
+ * «Ушёл» — `change:items`, а не `item:removed`: `plain` отдаёт события
+ * драйвера пробросом, а проброс срабатывает раньше обработчиков самого
+ * драйвера. На `item:removed` расширения коллекции на удаление ещё не
+ * ответили — Tabs не активировал соседа закрытого активного таба, —
+ * а `change:items` драйвер шлёт после всех `item:*` записи.
+ *
+ * Где фокус, видно только до удаления: после него узла элемента нет в
+ * реестре, а места — в коллекции. Поэтому узел и место (`host.place`) снимает
+ * и закрытие, и хук удаления (`item:remove:before`, `items:clear:before`).
+ * Переносится только фокус из узла уходящего элемента. Фокус, который увели,
+ * пока элемент уходил, остаётся, где его поставили; потерянный — ушедший на
+ * страницу вместе с узлом, который разметка сняла синхронно, — переносится,
+ * как стоявший в узле.
+ *
+ * Удаление, отменённое в хуке, фокус не трогает. Элемент, ушедший без
+ * закрытия, — снятый из данных или размонтированный, — фокус не переносит:
+ * иначе набор, который снимают целиком, гонял бы фокус по своим уходящим
+ * элементам. Такое ожидание висит до следующего ухода или закрытия элемента с
+ * фокусом, смены движка (`bind`) или сброса (`reset`): ожидание одно на
+ * коллекцию. Фокус помощник читает только при узле корня.
+ */
+export declare class TLeavingFocus<TItem extends object, TPlace> {
+    private readonly _elements;
+    private readonly _host;
+    private _plain;
+    private _leaving;
+    constructor(_elements: TCollectionElements | null, _host: TLeavingFocusHost<TItem, TPlace>);
+    /**
+     * Движок сменился — хуки удаления и состав слушаются у нового, ожидание
+     * прежнего забыто. `null` — снять подписки.
+     */
+    bind(plain: IPlainExtension<TItem> | null): void;
+    /**
+     * Элемент закрывают. Обычно он ещё в коллекции — закрытие удалит его
+     * следом, и фокус перейдёт на его уходе. Но подписчик закрытия, стоящий
+     * раньше плагина, мог уже снять его — и тогда фокус переходит сейчас.
+     */
+    close(item: TItem): void;
+    /** Забыть ожидание: узел корня снят. */
+    reset(): void;
+    private readonly _onRemoveBefore;
+    private readonly _onClearBefore;
+    /**
+     * Элементы вот-вот уйдут — пока их узлы в реестре, а места в коллекции,
+     * снять, не в них ли фокус и где они стоят. Уходит закрываемый элемент —
+     * его удаление запоминается: отменят — фокус останется на месте.
+     */
+    private _prepare;
+    /**
+     * Состав сменился — ушёл ли элемент. Драйвер шлёт `change:items` один раз
+     * на запись, после всех её `item:*`, когда расширения коллекции на них уже
+     * ответили.
+     */
+    private readonly _onItems;
+    /**
+     * Запомнить фокус элемента, если он в его узле, — вместе с местом
+     * элемента. Чтение фокуса — только при узле корня: на сервере документа
+     * нет.
+     *
+     * @returns запомнил ли — был ли фокус в узле элемента.
+     */
+    private _capture;
+    /**
+     * Удаление отменили (`item:remove:before`, `items:clear:before`) — элемент
+     * на месте, и фокус остаётся с ним. Видно это только после хука, поэтому
+     * ожидание сбрасывает следующее закрытие или удаление.
+     */
+    private _dropCancelled;
+    /** Элемент закрыли, и он ушёл — фокус переходит. */
+    private _settle;
+    /**
+     * Фокус, который увели из узла элемента, пока тот уходил, остаётся, где
+     * его поставили. Потерянный — ушедший на страницу вместе с узлом, который
+     * разметка сняла синхронно, — переносится, как стоявший в узле.
+     */
+    private _pass;
+}

package/dist/custom/collection/leaving-focus.js

@@ -0,0 +1,164 @@
+//#region src/custom/collection/leaving-focus.ts
+/**
+* Фокус уходящего элемента коллекции — элемента, который закрыли: клавишей,
+* крестиком, из кода. Узел элемента уходит из документа, и фокус, стоявший в
+* нём, ушёл бы на страницу: следующий Tab начинал бы обход заново.
+*
+* Правило одно на коллекции с закрытием — Tags и Tabs, поэтому ожидание —
+* модуль, а не копия в каждом плагине. Плагин слушает закрытие своего
+* расширения и решает, что запомнить о месте элемента и куда отдать фокус
+* (`host`), а когда переносить фокус и переносить ли вообще — помощник.
+*
+* Фокус переходит, когда сошлись два факта: элемент закрыли (`close` — плагин
+* зовёт его из `item:close` своего расширения) и элемент ушёл из коллекции
+* (`change:items` у `plain`), — вторым из них. Порядок у фактов разный:
+* обычно элемент удаляет само закрытие, следом за `item:close`, но подписчик
+* закрытия, стоящий раньше плагина, снимает его ещё в своём обработчике —
+* так поле Select снимает выбор с опции, а приложение может удалить таб из
+* своего обработчика события фасада, — и элемент уходит раньше, чем закрытие
+* дойдёт до плагина.
+*
+* «Ушёл» — `change:items`, а не `item:removed`: `plain` отдаёт события
+* драйвера пробросом, а проброс срабатывает раньше обработчиков самого
+* драйвера. На `item:removed` расширения коллекции на удаление ещё не
+* ответили — Tabs не активировал соседа закрытого активного таба, —
+* а `change:items` драйвер шлёт после всех `item:*` записи.
+*
+* Где фокус, видно только до удаления: после него узла элемента нет в
+* реестре, а места — в коллекции. Поэтому узел и место (`host.place`) снимает
+* и закрытие, и хук удаления (`item:remove:before`, `items:clear:before`).
+* Переносится только фокус из узла уходящего элемента. Фокус, который увели,
+* пока элемент уходил, остаётся, где его поставили; потерянный — ушедший на
+* страницу вместе с узлом, который разметка сняла синхронно, — переносится,
+* как стоявший в узле.
+*
+* Удаление, отменённое в хуке, фокус не трогает. Элемент, ушедший без
+* закрытия, — снятый из данных или размонтированный, — фокус не переносит:
+* иначе набор, который снимают целиком, гонял бы фокус по своим уходящим
+* элементам. Такое ожидание висит до следующего ухода или закрытия элемента с
+* фокусом, смены движка (`bind`) или сброса (`reset`): ожидание одно на
+* коллекцию. Фокус помощник читает только при узле корня.
+*/
+var TLeavingFocus = class {
+	_elements;
+	_host;
+	_plain = null;
+	_leaving;
+	constructor(_elements, _host) {
+		this._elements = _elements;
+		this._host = _host;
+	}
+	/**
+	* Движок сменился — хуки удаления и состав слушаются у нового, ожидание
+	* прежнего забыто. `null` — снять подписки.
+	*/
+	bind(plain) {
+		const previous = this._plain?.events;
+		previous?.off("item:remove:before", this._onRemoveBefore);
+		previous?.off("items:clear:before", this._onClearBefore);
+		previous?.off("change:items", this._onItems);
+		this._plain = plain;
+		this._leaving = void 0;
+		plain?.events.on("item:remove:before", this._onRemoveBefore);
+		plain?.events.on("items:clear:before", this._onClearBefore);
+		plain?.events.on("change:items", this._onItems);
+	}
+	/**
+	* Элемент закрывают. Обычно он ещё в коллекции — закрытие удалит его
+	* следом, и фокус перейдёт на его уходе. Но подписчик закрытия, стоящий
+	* раньше плагина, мог уже снять его — и тогда фокус переходит сейчас.
+	*/
+	close(item) {
+		this._dropCancelled();
+		const leaving = this._leaving;
+		if (leaving?.item === item) {
+			leaving.closed = true;
+			this._settle(leaving);
+			return;
+		}
+		this._capture(item, { closed: true });
+	}
+	/** Забыть ожидание: узел корня снят. */
+	reset() {
+		this._leaving = void 0;
+	}
+	_onRemoveBefore = (event) => this._prepare([event.item], event);
+	_onClearBefore = (event) => this._prepare(event.items, event);
+	/**
+	* Элементы вот-вот уйдут — пока их узлы в реестре, а места в коллекции,
+	* снять, не в них ли фокус и где они стоят. Уходит закрываемый элемент —
+	* его удаление запоминается: отменят — фокус останется на месте.
+	*/
+	_prepare(items, removal) {
+		this._dropCancelled();
+		const leaving = this._leaving;
+		if (leaving && items.includes(leaving.item)) {
+			leaving.removal = removal;
+			return;
+		}
+		for (const item of items) if (this._capture(item, {
+			closed: false,
+			removal
+		})) return;
+	}
+	/**
+	* Состав сменился — ушёл ли элемент. Драйвер шлёт `change:items` один раз
+	* на запись, после всех её `item:*`, когда расширения коллекции на них уже
+	* ответили.
+	*/
+	_onItems = ({ newValue: items }) => {
+		const leaving = this._leaving;
+		if (!leaving || items.includes(leaving.item)) return;
+		leaving.left = true;
+		this._settle(leaving);
+	};
+	/**
+	* Запомнить фокус элемента, если он в его узле, — вместе с местом
+	* элемента. Чтение фокуса — только при узле корня: на сервере документа
+	* нет.
+	*
+	* @returns запомнил ли — был ли фокус в узле элемента.
+	*/
+	_capture(item, state) {
+		const root = this._host.root();
+		const node = root ? this._elements?.getElementByItem(item) ?? null : null;
+		const active = root?.ownerDocument.activeElement;
+		if (!node || !active || !node.contains(active)) return false;
+		this._leaving = {
+			item,
+			node,
+			place: this._host.place(item),
+			left: false,
+			...state
+		};
+		return true;
+	}
+	/**
+	* Удаление отменили (`item:remove:before`, `items:clear:before`) — элемент
+	* на месте, и фокус остаётся с ним. Видно это только после хука, поэтому
+	* ожидание сбрасывает следующее закрытие или удаление.
+	*/
+	_dropCancelled() {
+		if (this._leaving?.removal?.defaultPrevented) this._leaving = void 0;
+	}
+	/** Элемент закрыли, и он ушёл — фокус переходит. */
+	_settle(leaving) {
+		if (!leaving.closed || !leaving.left) return;
+		this._leaving = void 0;
+		this._pass(leaving);
+	}
+	/**
+	* Фокус, который увели из узла элемента, пока тот уходил, остаётся, где
+	* его поставили. Потерянный — ушедший на страницу вместе с узлом, который
+	* разметка сняла синхронно, — переносится, как стоявший в узле.
+	*/
+	_pass(leaving) {
+		const root = this._host.root();
+		if (!root) return;
+		const { activeElement, body } = root.ownerDocument;
+		if (activeElement && activeElement !== body && !leaving.node.contains(activeElement)) return;
+		this._host.pass(root, leaving.place);
+	}
+};
+//#endregion
+export { TLeavingFocus };

package/dist/custom/collection/reachable.d.ts

@@ -0,0 +1,14 @@
+import type { IControl } from '@soxa-ui/core';
+/**
+ * Элемент коллекции, на который можно перевести фокус: не выключен, видим и
+ * отрисован. Выключенное поле и скрытый узел фокус не примут, и запись
+ * `focused = true` ушла бы в пустоту, хотя рядом есть элемент, который его
+ * примет.
+ *
+ * Правило узла фокуса для коллекций, у которых своей остановки в модели нет:
+ * у секций Accordion остановок столько же, сколько заголовков, а остановку
+ * радио выбирает браузер. Где остановка в модели есть — у табов и тегов, —
+ * правило той же формы держит расширение коллекции (`isEnabledTab`,
+ * `isEnabledTag`), и копии здесь у него нет.
+ */
+export declare function isReachable(item: Pick<IControl, 'disabled' | 'visible' | 'rendered'>): boolean;

package/dist/custom/collection/reachable.js

@@ -0,0 +1,18 @@
+//#region src/custom/collection/reachable.ts
+/**
+* Элемент коллекции, на который можно перевести фокус: не выключен, видим и
+* отрисован. Выключенное поле и скрытый узел фокус не примут, и запись
+* `focused = true` ушла бы в пустоту, хотя рядом есть элемент, который его
+* примет.
+*
+* Правило узла фокуса для коллекций, у которых своей остановки в модели нет:
+* у секций Accordion остановок столько же, сколько заголовков, а остановку
+* радио выбирает браузер. Где остановка в модели есть — у табов и тегов, —
+* правило той же формы держит расширение коллекции (`isEnabledTab`,
+* `isEnabledTag`), и копии здесь у него нет.
+*/
+function isReachable(item) {
+	return !item.disabled && item.visible && item.rendered;
+}
+//#endregion
+export { isReachable };

package/dist/custom/collection/types.d.ts

@@ -0,0 +1,14 @@
+import type { TCollectionEngine } from '@soxa-ui/core';
+import type { IPluginBundle, TPluginEvents } from '../../base';
+/** События реестра bundles элементов коллекции. */
+export type TBundlesEvents = TPluginEvents & {
+    /** Коллекция привязана к реестру (вызывается bindEngine). */
+    'engine:bound': (engine: TCollectionEngine<any, any>) => void;
+    'bundle:registered': (payload: {
+        uid: string | number;
+        bundle: IPluginBundle;
+    }) => void;
+    'bundle:unregistered': (payload: {
+        uid: string | number;
+    }) => void;
+};