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

package/dist/content/descriptors/plugins/tooltip-trigger.plugin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Определение TTooltipTriggerPlugin (namespace `trigger`) — когда подсказка
+ * показывается и когда прячется.
+ *
+ * Наведение с задержкой, фокус с клавиатуры, нажатие и Escape ведут `open`
+ * владельца, см. `TTooltipTriggerPlugin`. Ставится после `TDismissPlugin`:
+ * берёт у него панель.
+ */
+import { TTooltipTriggerPlugin } from '@soxa-ui/plugins';
+export declare const TooltipTriggerPluginDescriptor: import("../../..").IPluginDefinition<import("../../../protected/define/inference.types").TPluginContractFrom<TTooltipTriggerPlugin, "trigger", {}>>;

package/dist/content/descriptors/plugins/tooltip-trigger.plugin.js

@@ -0,0 +1,23 @@
+import { definePlugin } from "../../../protected/define/plugin.js";
+import { TTooltipTriggerPlugin } from "@soxa-ui/plugins";
+//#region content/descriptors/plugins/tooltip-trigger.plugin.ts
+/**
+* Определение TTooltipTriggerPlugin (namespace `trigger`) — когда подсказка
+* показывается и когда прячется.
+*
+* Наведение с задержкой, фокус с клавиатуры, нажатие и Escape ведут `open`
+* владельца, см. `TTooltipTriggerPlugin`. Ставится после `TDismissPlugin`:
+* берёт у него панель.
+*/
+var TooltipTriggerPluginDescriptor = definePlugin({
+	ctor: TTooltipTriggerPlugin,
+	namespace: "trigger",
+	/**
+	* Ничего не отдаёт наружу: открытость (`open`) и задержки — пропсы
+	* владельца. Контрибуция нужна лишь для того, чтобы `create` попал в
+	* события, как у любого плагина.
+	*/
+	contribution: {}
+});
+//#endregion
+export { TooltipTriggerPluginDescriptor };

package/dist/content/extensions/collection/collection-item.extension.class.d.ts

@@ -0,0 +1,64 @@
+/**
+ * TCollectionItemExtension — an item of a collection: its assembly on mount
+ * and its entry into the collection.
+ *
+ * The work follows the context's phases; when each comes is the adapter
+ * runtime's call:
+ *
+ * - **assembly** (constructor) — through the lift: the own collection's
+ *   engine, its registrar and the markup group above the item; the item
+ *   context goes into the facade, `meta` is taken from the props. Nothing is
+ *   written into the owner's storage. The context releases the assembly props
+ *   on `connect()`, so the extension is installed right after the context is
+ *   created;
+ * - **entry** (`attach`) — registration in the owner's collection and
+ *   `meta.apply`. This writes into someone else's storage, so it waits until
+ *   the framework accepts the component: React assembles on render, and a
+ *   discarded render would leave a phantom in the engine, while an item added
+ *   after the mount would update its owner in the middle of a child's render.
+ *   From entry to teardown the item's own context (`adapter`, its instance is
+ *   the item) and the facade's are members of the collection
+ *   (`TCollectionMembers`): when the whole
+ *   collection comes down, the owner's `detach` detaches them, and an item
+ *   does not hear its siblings leave;
+ * - **teardown** (`destroy`) — leaving the collection and releasing the item
+ *   context.
+ *
+ * The own collection is the nearest one above, if the item is of it. The lift
+ * gives the nearest engine, and it may be foreign: a tag outside Tags under an
+ * app-wide `<Toasts>`, a tag or a radio in a Tabs panel. Whose an item is, the
+ * engine's factory knows (`factoryOf(...).isSource`): anything else it turns
+ * into an item of its own class — a radio entering Tabs became a tab — and the
+ * facade, lacking its own collection's extensions, failed to assemble. A
+ * foreign collection is treated as absent: no item context, no entry, no
+ * `meta`, the item renders on its own. There is no warning: under `<Toasts>`
+ * almost any single item stands under a foreign collection, legitimately.
+ *
+ * The item context (`TItemContext`) belongs to this mount. Its item adapters
+ * subscribe to the engine's extensions, and the engine outlives the mount: a
+ * data item hidden by a filter or a page stays in the collection and mounts
+ * again, React reassembles without unmounting (StrictMode, `<Activity>`). So
+ * teardown releases the context, or every show would leave subscribers on the
+ * engine, and clears the facade, since React rereads the state of a destroyed
+ * assembly and the facade would recreate the adapters. One context per item
+ * for all mounts would not do: a tab and its panel take the same item's
+ * context, and one releasing it would break the other.
+ *
+ * An item removed from the collection while mounted destroys its context
+ * (`TItemContext.destroy`). A markup item leaving on teardown is not a
+ * removal: `rendered` of an external `ctrl` stays as it is, and mounted again
+ * the item renders.
+ *
+ * An item inside a markup group (`Menu.Group`, `ListBox.Group` and the like)
+ * joins that group: the key lowered by `TItemGroupExtension` goes into the
+ * item's `meta` as `group`, the channel `_.group` takes in data. Only an item
+ * the entry adds to the list takes the key — a data item keeps the group of
+ * its data, even when the owner renders it inside a section — and only from
+ * its own collection: submenu items inside a menu group are the submenu's.
+ */
+import type { TInstanceContext } from '../../../protected/adapter/context';
+import type { ICollectionItemExtensionOptions, TCollectionItemFacade } from './types';
+export declare class TCollectionItemExtension {
+    private _leave;
+    constructor(context: TInstanceContext<TCollectionItemFacade>, options: ICollectionItemExtensionOptions);
+}

package/dist/content/extensions/collection/collection-item.extension.class.js

@@ -0,0 +1,111 @@
+import { COLLECTION_ENGINE_ELEVATOR, ITEM_CONTEXT_ELEVATOR } from "../../../protected/adapter/elevator/keys.js";
+import { COLLECTION_MEMBERS_ELEVATOR } from "./keys.js";
+import { ITEM_GROUP_ELEVATOR } from "../item-group/keys.js";
+import { collectItemProps } from "./item-props.js";
+import { TItemContext, batchOf, factoryOf, metaOf, plainOf } from "@soxa-ui/core";
+//#region content/extensions/collection/collection-item.extension.class.ts
+/**
+* TCollectionItemExtension — an item of a collection: its assembly on mount
+* and its entry into the collection.
+*
+* The work follows the context's phases; when each comes is the adapter
+* runtime's call:
+*
+* - **assembly** (constructor) — through the lift: the own collection's
+*   engine, its registrar and the markup group above the item; the item
+*   context goes into the facade, `meta` is taken from the props. Nothing is
+*   written into the owner's storage. The context releases the assembly props
+*   on `connect()`, so the extension is installed right after the context is
+*   created;
+* - **entry** (`attach`) — registration in the owner's collection and
+*   `meta.apply`. This writes into someone else's storage, so it waits until
+*   the framework accepts the component: React assembles on render, and a
+*   discarded render would leave a phantom in the engine, while an item added
+*   after the mount would update its owner in the middle of a child's render.
+*   From entry to teardown the item's own context (`adapter`, its instance is
+*   the item) and the facade's are members of the collection
+*   (`TCollectionMembers`): when the whole
+*   collection comes down, the owner's `detach` detaches them, and an item
+*   does not hear its siblings leave;
+* - **teardown** (`destroy`) — leaving the collection and releasing the item
+*   context.
+*
+* The own collection is the nearest one above, if the item is of it. The lift
+* gives the nearest engine, and it may be foreign: a tag outside Tags under an
+* app-wide `<Toasts>`, a tag or a radio in a Tabs panel. Whose an item is, the
+* engine's factory knows (`factoryOf(...).isSource`): anything else it turns
+* into an item of its own class — a radio entering Tabs became a tab — and the
+* facade, lacking its own collection's extensions, failed to assemble. A
+* foreign collection is treated as absent: no item context, no entry, no
+* `meta`, the item renders on its own. There is no warning: under `<Toasts>`
+* almost any single item stands under a foreign collection, legitimately.
+*
+* The item context (`TItemContext`) belongs to this mount. Its item adapters
+* subscribe to the engine's extensions, and the engine outlives the mount: a
+* data item hidden by a filter or a page stays in the collection and mounts
+* again, React reassembles without unmounting (StrictMode, `<Activity>`). So
+* teardown releases the context, or every show would leave subscribers on the
+* engine, and clears the facade, since React rereads the state of a destroyed
+* assembly and the facade would recreate the adapters. One context per item
+* for all mounts would not do: a tab and its panel take the same item's
+* context, and one releasing it would break the other.
+*
+* An item removed from the collection while mounted destroys its context
+* (`TItemContext.destroy`). A markup item leaving on teardown is not a
+* removal: `rendered` of an external `ctrl` stays as it is, and mounted again
+* the item renders.
+*
+* An item inside a markup group (`Menu.Group`, `ListBox.Group` and the like)
+* joins that group: the key lowered by `TItemGroupExtension` goes into the
+* item's `meta` as `group`, the channel `_.group` takes in data. Only an item
+* the entry adds to the list takes the key — a data item keeps the group of
+* its data, even when the owner renders it inside a section — and only from
+* its own collection: submenu items inside a menu group are the submenu's.
+*/
+/** The nearest collection's engine, if the item is of it: its factory takes the item as its own. */
+function ownEngine(engine, item) {
+	const factory = factoryOf(engine);
+	return factory && !factory.isSource(item) ? engine : void 0;
+}
+var TCollectionItemExtension = class {
+	_leave;
+	constructor(context, options) {
+		const { adapter, elevator } = options;
+		const item = adapter.instance;
+		const { props } = context;
+		if (!props) throw new Error("TCollectionItemExtension ставится до connect(): пропсы сборки, из которых берётся meta элемента, контекст уже отпустил");
+		const engine = ownEngine(elevator(ITEM_CONTEXT_ELEVATOR).up(), item);
+		const register = engine ? elevator(COLLECTION_ENGINE_ELEVATOR).up() : void 0;
+		const members = engine ? elevator(COLLECTION_MEMBERS_ELEVATOR).up() : void 0;
+		const link = engine ? elevator(ITEM_GROUP_ELEVATOR).up() : void 0;
+		const groupKey = link && link.engine === engine ? link.key : void 0;
+		const meta = collectItemProps(context.descriptor.props, props);
+		const itemContext = engine ? new TItemContext(item, engine.extensions) : void 0;
+		const plain = plainOf(engine);
+		if (itemContext) context.instance.setContext(itemContext);
+		const removed = (e) => {
+			if (e.item === item) itemContext?.destroy();
+		};
+		context.events.on("attach", () => {
+			plain?.events.on("item:removed", removed);
+			const grouped = groupKey !== void 0 && !batchOf(engine)?.items.includes(item);
+			if (grouped) link?.enter();
+			if (register) this._leave = register(item, context.bundle);
+			members?.add(adapter, context);
+			metaOf(engine)?.apply(item, grouped ? {
+				...meta,
+				group: groupKey
+			} : meta);
+		});
+		context.events.on("destroy", () => {
+			plain?.events.off("item:removed", removed);
+			members?.delete(adapter, context);
+			this._leave?.();
+			this._leave = void 0;
+			context.instance.clearContext();
+			itemContext?.release();
+		});
+	}
+};
+//#endregion
+export { TCollectionItemExtension };

package/dist/content/extensions/collection/collection.extension.class.d.ts

@@ -0,0 +1,21 @@
+/**
+ * TCollectionExtension — the single entry point that sets up a collection. The
+ * facade owns the `engine`.
+ *
+ * It binds the engine to the bundle registry and lowers to the children,
+ * through the lift: the engine (`ITEM_CONTEXT_ELEVATOR`), the item registrar
+ * (`COLLECTION_ENGINE_ELEVATOR`), the bundle registry
+ * (`COLLECTION_BUNDLES_ELEVATOR`) and the members (`COLLECTION_MEMBERS_ELEVATOR`).
+ *
+ * The registry is for children that do not enter the collection but are tied
+ * to its items: a `Tabs.Content` panel hands its `id` to its tab's link plugin
+ * and finds the bundle of the tab's current mount in the registry. The
+ * members are detached by the owner's `detach` (`TCollectionMembers`).
+ */
+import type { TInstanceContext } from '../../../protected/adapter/context';
+import type { ICollectionExtensionOptions, TCollectionOwner } from './types';
+export declare class TCollectionExtension {
+    constructor(context: TInstanceContext<TCollectionOwner>, options: ICollectionExtensionOptions);
+    /** Binds the engine to the plugins and lowers the item registrar through the lift. */
+    private _wire;
+}

package/dist/content/extensions/collection/collection.extension.class.js

@@ -0,0 +1,57 @@
+import { applyRegisteredExtensions } from "../../../protected/registry/extensions.js";
+import { COLLECTION_ENGINE_ELEVATOR, ITEM_CONTEXT_ELEVATOR } from "../../../protected/adapter/elevator/keys.js";
+import { COLLECTION_BUNDLES_ELEVATOR, COLLECTION_MEMBERS_ELEVATOR } from "./keys.js";
+import { TCollectionMembers } from "./members.class.js";
+import { batchOf, plainOf } from "@soxa-ui/core";
+import { TCollectionBundlesPlugin } from "@soxa-ui/plugins";
+//#region content/extensions/collection/collection.extension.class.ts
+/**
+* TCollectionExtension — the single entry point that sets up a collection. The
+* facade owns the `engine`.
+*
+* It binds the engine to the bundle registry and lowers to the children,
+* through the lift: the engine (`ITEM_CONTEXT_ELEVATOR`), the item registrar
+* (`COLLECTION_ENGINE_ELEVATOR`), the bundle registry
+* (`COLLECTION_BUNDLES_ELEVATOR`) and the members (`COLLECTION_MEMBERS_ELEVATOR`).
+*
+* The registry is for children that do not enter the collection but are tied
+* to its items: a `Tabs.Content` panel hands its `id` to its tab's link plugin
+* and finds the bundle of the tab's current mount in the registry. The
+* members are detached by the owner's `detach` (`TCollectionMembers`).
+*/
+var TCollectionExtension = class {
+	constructor(context, options) {
+		const { elevator } = options;
+		const engine = context.instance.engine;
+		if (!engine) throw new Error("Engine is not available in the engine instance.");
+		elevator(ITEM_CONTEXT_ELEVATOR).down(engine);
+		this._wire(context, elevator, engine);
+		const members = new TCollectionMembers();
+		elevator(COLLECTION_MEMBERS_ELEVATOR).down(members);
+		context.events.on("detach", () => members.detach());
+		context.events.on("attach", () => context.instance.bindOwner());
+		context.events.on("destroy", () => context.instance.releaseOwner());
+	}
+	/** Binds the engine to the plugins and lowers the item registrar through the lift. */
+	_wire(context, elevator, engine) {
+		const bundles = context.bundle?.get(TCollectionBundlesPlugin);
+		if (bundles) bundles.bindEngine(engine);
+		elevator(COLLECTION_BUNDLES_ELEVATOR).down(bundles ?? null);
+		const owner = context.bundle?.getInstance();
+		if (owner) applyRegisteredExtensions(owner, engine, { embedded: context.embedded });
+		elevator(COLLECTION_ENGINE_ELEVATOR).down((instance, bundle) => {
+			const batch = batchOf(engine);
+			const owned = !batch?.items.includes(instance);
+			if (owned) plainOf(engine)?.push(instance);
+			const release = owned ? batch?.hold(instance) : void 0;
+			if (bundle) bundles?.register(bundle, instance);
+			return () => {
+				release?.();
+				if (owned) plainOf(engine)?.remove(instance);
+				else if (bundle) bundles?.release(bundle, instance);
+			};
+		});
+	}
+};
+//#endregion
+export { TCollectionExtension };

package/dist/content/extensions/collection/index.d.ts

@@ -0,0 +1,3 @@
+export { TCollectionExtension } from './collection.extension.class';
+export { TCollectionItemExtension } from './collection-item.extension.class';
+export type { ICollectionExtensionOptions, ICollectionItemExtensionOptions, TCollectionItemFacade, TCollectionOwner, TMemberAdapter, } from './types';

package/dist/content/extensions/collection/item-props.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Входные пропсы элемента коллекции, объявленные его дескриптором, — для `meta` движка.
+ */
+import type { TPropSpec } from '../../../protected/define';
+/**
+ * Собрать значения входных (не protected) пропсов, объявленных в `decls`,
+ * из набора `props`. Ключ результата — сырое имя пропса (`decl.name.name`).
+ *
+ * Потребитель один — `TCollectionItemExtension`, поэтому наружу пакета функция
+ * не выходит: разметка передала элементу `active`/`selected`, и расширение
+ * кладёт их в `meta` движка, где состав элемента и живёт.
+ */
+export declare function collectItemProps(decls: readonly TPropSpec[], props: object): Record<string, unknown>;

package/dist/content/extensions/collection/item-props.js

@@ -0,0 +1,20 @@
+//#region content/extensions/collection/item-props.ts
+/**
+* Собрать значения входных (не protected) пропсов, объявленных в `decls`,
+* из набора `props`. Ключ результата — сырое имя пропса (`decl.name.name`).
+*
+* Потребитель один — `TCollectionItemExtension`, поэтому наружу пакета функция
+* не выходит: разметка передала элементу `active`/`selected`, и расширение
+* кладёт их в `meta` движка, где состав элемента и живёт.
+*/
+function collectItemProps(decls, props) {
+	const result = {};
+	for (const decl of decls) {
+		if (decl.protected) continue;
+		const value = Reflect.get(props, decl.name.name);
+		if (value !== void 0) result[decl.name.name] = value;
+	}
+	return result;
+}
+//#endregion
+export { collectItemProps };

package/dist/content/extensions/collection/keys.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lift keys of the collection, lowered by its owner beside the engine. They
+ * live apart from the wiring, as the group key (`ITEM_GROUP_ELEVATOR`) does:
+ * the lift takes any key, so keys belong to the content, not to the lift's
+ * mechanics.
+ */
+import type { TCollectionBundlesPlugin } from '@soxa-ui/plugins';
+import type { IElevatorKey } from '../../../protected/adapter/elevator';
+import type { TCollectionMembers } from './members.class';
+/**
+ * The registry of the nearest collection's item bundles
+ * (`TCollectionBundlesPlugin`), of the same owner as the engine under
+ * `ITEM_CONTEXT_ELEVATOR`; an item's bundle in it is of its current mount. An
+ * owner without a registry lowers `null`, so that a collection's registry
+ * above does not reach its subtree.
+ */
+export declare const COLLECTION_BUNDLES_ELEVATOR: IElevatorKey<TCollectionBundlesPlugin | null>;
+/**
+ * The members of the nearest collection, of the same owner as the engine: an
+ * item and a part bound to an item join on entry and leave when their mount
+ * ends.
+ */
+export declare const COLLECTION_MEMBERS_ELEVATOR: IElevatorKey<TCollectionMembers>;

package/dist/content/extensions/collection/keys.js

@@ -0,0 +1,17 @@
+//#region content/extensions/collection/keys.ts
+/**
+* The registry of the nearest collection's item bundles
+* (`TCollectionBundlesPlugin`), of the same owner as the engine under
+* `ITEM_CONTEXT_ELEVATOR`; an item's bundle in it is of its current mount. An
+* owner without a registry lowers `null`, so that a collection's registry
+* above does not reach its subtree.
+*/
+var COLLECTION_BUNDLES_ELEVATOR = { name: "soxa:collection-bundles" };
+/**
+* The members of the nearest collection, of the same owner as the engine: an
+* item and a part bound to an item join on entry and leave when their mount
+* ends.
+*/
+var COLLECTION_MEMBERS_ELEVATOR = { name: "soxa:collection-members" };
+//#endregion
+export { COLLECTION_BUNDLES_ELEVATOR, COLLECTION_MEMBERS_ELEVATOR };

package/dist/content/extensions/collection/members.class.d.ts

@@ -0,0 +1,24 @@
+/**
+ * TCollectionMembers — the contexts of a collection's members mounted now:
+ * its items and the parts bound to them (a panel of Tabs). The collection
+ * detaches them with itself.
+ *
+ * A framework that removes a subtree in one pass (Svelte, Solid, Angular)
+ * destroys the members one by one: the first to go leaves the collection, and
+ * the others — still mounted — hear their order and the activation move. Two
+ * passes (Vue, React) end every subscription before anything is destroyed.
+ * The owner's `detach` is the first moment of its teardown in every adapter,
+ * before its children go, so the collection reports it to its members as
+ * their own (`IAdapterContext.detach`), and what follows is up to the
+ * adapter: the consumer hears nothing from then on.
+ */
+import type { IDetachable } from './types';
+export declare class TCollectionMembers {
+    private readonly _contexts;
+    /** A member joined the collection: its contexts. */
+    add(...contexts: readonly IDetachable[]): void;
+    /** A member's mount ended. */
+    delete(...contexts: readonly IDetachable[]): void;
+    /** The collection began coming down: its members did too. */
+    detach(): void;
+}

package/dist/content/extensions/collection/members.class.js

@@ -0,0 +1,18 @@
+//#region content/extensions/collection/members.class.ts
+var TCollectionMembers = class {
+	_contexts = /* @__PURE__ */ new Set();
+	/** A member joined the collection: its contexts. */
+	add(...contexts) {
+		for (const context of contexts) this._contexts.add(context);
+	}
+	/** A member's mount ended. */
+	delete(...contexts) {
+		for (const context of contexts) this._contexts.delete(context);
+	}
+	/** The collection began coming down: its members did too. */
+	detach() {
+		for (const context of this._contexts) context.detach();
+	}
+};
+//#endregion
+export { TCollectionMembers };

package/dist/content/extensions/collection/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Contracts of the collection extensions: the instance each is installed on, and its options.
+ */
+import type { TCollectionEngine, TItemContext } from '@soxa-ui/core';
+import type { TInstanceContext } from '../../../protected/adapter/context';
+import type { TElevatorFactory } from '../../../protected/adapter/elevator';
+/**
+ * The instance `TCollectionExtension` is installed on: the facade that owns
+ * the collection. Acceptance binds the owner to the engine, destruction
+ * releases it.
+ */
+export type TCollectionOwner = {
+    readonly engine: TCollectionEngine<any, any>;
+    bindOwner(): void;
+    releaseOwner(): void;
+};
+export interface ICollectionExtensionOptions {
+    elevator: TElevatorFactory;
+}
+/**
+ * The instance `TCollectionItemExtension` is installed on: the item facade,
+ * which takes the item context for the mount and lets it go at the end.
+ */
+export type TCollectionItemFacade = {
+    setContext(context: TItemContext<any, any>): void;
+    clearContext(): void;
+};
+/** A context the collection detaches with itself (`TCollectionMembers`). */
+export interface IDetachable {
+    detach(): void;
+}
+/**
+ * The own adapter context of a collection member, of its own descriptor, not
+ * of the facade: its instance is the collection's item, and the collection
+ * detaches it with itself.
+ */
+export type TMemberAdapter<TInstance extends object = object> = Pick<TInstanceContext<TInstance>, 'instance' | 'detach'>;
+export interface ICollectionItemExtensionOptions {
+    adapter: TMemberAdapter;
+    elevator: TElevatorFactory;
+}

package/dist/content/extensions/drag-and-drop/drag-and-drop-collection.extension.class.d.ts

@@ -0,0 +1,26 @@
+/**
+ * TDragAndDropCollectionExtension — коллекция подхватывает обёртку `DragAndDrop` над собой.
+ *
+ * Обёртку опускает по лифту её проводка (`TDragAndDropExtension`). Коллекция
+ * берёт её при сборке и включает плагин перетаскивания своего набора
+ * (`TDragPlugin`) — своим движком и обёрткой: жест плагин переводит в команду
+ * обёртки (`IDragAndDrop.move`), и о перестановке сообщают её события.
+ *
+ * Обёртки выше нет — коллекция не перетаскивается.
+ *
+ * Своему поддереву коллекция опускает пустое значение: списки в её элементах
+ * (ListBox в секции Accordion) перестановку не наследуют.
+ *
+ * Фаз контекста у подхвата нет: на шину обёртки коллекция не подписывается,
+ * а плагин уходит вместе с её набором.
+ *
+ * Использование:
+ *   adapter.use(TCollectionExtension, { elevator: VueElevatorFactory })
+ *     .use(TDragAndDropCollectionExtension, { elevator: VueElevatorFactory })
+ */
+import type { TInstanceContext } from '../../../protected/adapter/context';
+import type { TCollectionOwner } from '../collection';
+import type { IDragAndDropCollectionExtensionOptions } from './types';
+export declare class TDragAndDropCollectionExtension {
+    constructor(context: TInstanceContext<TCollectionOwner>, options: IDragAndDropCollectionExtensionOptions);
+}

package/dist/content/extensions/drag-and-drop/drag-and-drop-collection.extension.class.js

@@ -0,0 +1,34 @@
+import { DRAG_AND_DROP_ELEVATOR } from "./keys.js";
+import { TDragPlugin } from "@soxa-ui/plugins";
+//#region content/extensions/drag-and-drop/drag-and-drop-collection.extension.class.ts
+/**
+* TDragAndDropCollectionExtension — коллекция подхватывает обёртку `DragAndDrop` над собой.
+*
+* Обёртку опускает по лифту её проводка (`TDragAndDropExtension`). Коллекция
+* берёт её при сборке и включает плагин перетаскивания своего набора
+* (`TDragPlugin`) — своим движком и обёрткой: жест плагин переводит в команду
+* обёртки (`IDragAndDrop.move`), и о перестановке сообщают её события.
+*
+* Обёртки выше нет — коллекция не перетаскивается.
+*
+* Своему поддереву коллекция опускает пустое значение: списки в её элементах
+* (ListBox в секции Accordion) перестановку не наследуют.
+*
+* Фаз контекста у подхвата нет: на шину обёртки коллекция не подписывается,
+* а плагин уходит вместе с её набором.
+*
+* Использование:
+*   adapter.use(TCollectionExtension, { elevator: VueElevatorFactory })
+*     .use(TDragAndDropCollectionExtension, { elevator: VueElevatorFactory })
+*/
+var TDragAndDropCollectionExtension = class {
+	constructor(context, options) {
+		const elevator = options.elevator(DRAG_AND_DROP_ELEVATOR);
+		const dragAndDrop = elevator.up();
+		elevator.down(null);
+		if (!dragAndDrop) return;
+		context.bundle?.get(TDragPlugin)?.activate(context.instance.engine, dragAndDrop);
+	}
+};
+//#endregion
+export { TDragAndDropCollectionExtension };

package/dist/content/extensions/drag-and-drop/drag-and-drop.extension.class.d.ts

@@ -0,0 +1,21 @@
+/**
+ * TDragAndDropExtension — проводка обёртки `DragAndDrop`: перестановка коллекциям внутри неё.
+ *
+ * Обёртка опускает по лифту свой экземпляр, а коллекция внутри подхватывает
+ * его при сборке (`TDragAndDropCollectionExtension`) и включает им свой плагин
+ * перетаскивания: жест коллекции становится командой обёртки
+ * (`IDragAndDrop.move`), со своими событиями.
+ *
+ * Фаз контекста у проводки нет, в отличие от окна (`TVirtualExtension`): на
+ * шину обёртки никто не подписан — плагин коллекции только зовёт её команду и
+ * уходит вместе с набором коллекции.
+ *
+ * Использование:
+ *   adapter.use(TDragAndDropExtension, { elevator: VueElevatorFactory })
+ */
+import type { IDragAndDrop } from '@soxa-ui/core';
+import type { TInstanceContext } from '../../../protected/adapter/context';
+import type { IDragAndDropExtensionOptions } from './types';
+export declare class TDragAndDropExtension {
+    constructor(context: TInstanceContext<IDragAndDrop>, options: IDragAndDropExtensionOptions);
+}

package/dist/content/extensions/drag-and-drop/drag-and-drop.extension.class.js

@@ -0,0 +1,9 @@
+import { DRAG_AND_DROP_ELEVATOR } from "./keys.js";
+//#region content/extensions/drag-and-drop/drag-and-drop.extension.class.ts
+var TDragAndDropExtension = class {
+	constructor(context, options) {
+		options.elevator(DRAG_AND_DROP_ELEVATOR).down(context.instance);
+	}
+};
+//#endregion
+export { TDragAndDropExtension };

package/dist/content/extensions/drag-and-drop/index.d.ts

@@ -0,0 +1,3 @@
+export { TDragAndDropExtension } from './drag-and-drop.extension.class';
+export { TDragAndDropCollectionExtension } from './drag-and-drop-collection.extension.class';
+export type { IDragAndDropCollectionExtensionOptions, IDragAndDropExtensionOptions } from './types';

package/dist/content/extensions/drag-and-drop/keys.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Ключ лифта перестановки: обёртка `DragAndDrop` опускает по нему коллекциям внутри себя свой экземпляр.
+ *
+ * Лежит отдельно от проводки обёртки, как ключ окна (`virtual/keys.ts`):
+ * коллекция импортирует ключ и типы, а не проводку обёртки. Лифт берёт любой
+ * ключ, поэтому ключ — в наполнении, а не в механике лифта.
+ */
+import type { IDragAndDrop } from '@soxa-ui/core';
+import type { IElevatorKey } from '../../../protected/adapter/elevator';
+/**
+ * Обёртка, командой которой коллекция переставляет свои элементы. Пустое
+ * значение опускает своему поддереву сама коллекция: списки в её элементах
+ * перестановку не наследуют.
+ */
+export declare const DRAG_AND_DROP_ELEVATOR: IElevatorKey<IDragAndDrop | null>;

package/dist/content/extensions/drag-and-drop/keys.js

@@ -0,0 +1,9 @@
+//#region content/extensions/drag-and-drop/keys.ts
+/**
+* Обёртка, командой которой коллекция переставляет свои элементы. Пустое
+* значение опускает своему поддереву сама коллекция: списки в её элементах
+* перестановку не наследуют.
+*/
+var DRAG_AND_DROP_ELEVATOR = { name: "soxa:drag-and-drop" };
+//#endregion
+export { DRAG_AND_DROP_ELEVATOR };

package/dist/content/extensions/drag-and-drop/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Опции расширений drag-and-drop: лифт, по которому обёртка идёт к коллекциям.
+ */
+import type { TElevatorFactory } from '../../../protected/adapter/elevator';
+export interface IDragAndDropExtensionOptions {
+    elevator: TElevatorFactory;
+}
+export interface IDragAndDropCollectionExtensionOptions {
+    elevator: TElevatorFactory;
+}