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

package/dist/adapter/elevator/layer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Слой лифта — неизменяемая карта «ключ → значение» от предков, один
+ * контекст React на все ключи. AGENTS.md (React), «Срок жизни контекста».
+ */
+export type TElevatorLayer = ReadonlyMap<symbol, unknown>;
+export declare const ElevatorContext: import("react").Context<TElevatorLayer>;

package/dist/adapter/elevator/layer.js

@@ -0,0 +1,5 @@
+"use client";
+import { createContext } from "react";
+var ElevatorContext = createContext(/* @__PURE__ */ new Map());
+//#endregion
+export { ElevatorContext };

package/dist/adapter/elevator/scope.class.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TReactElevatorScope — лифт одной сборки: родительский слой, своё и
+ * прочитанное. Сменилось прочитанное — сборка устарела (`isStale`).
+ */
+import type { TElevatorFactory } from '@soxa-ui/setup';
+import type { TElevatorLayer } from './layer';
+export declare class TReactElevatorScope {
+    readonly parent: TElevatorLayer;
+    private readonly _own;
+    private readonly _reads;
+    /** @param parent слой, который компонент увидел на рендере */
+    constructor(parent: TElevatorLayer);
+    readonly elevator: TElevatorFactory;
+    read(key: symbol): unknown;
+    write(key: symbol, value: unknown): void;
+    isStale(layer: TElevatorLayer): boolean;
+    /** Слой для детей; своего нет — тот же объект, детям не из-за чего перерисовываться. */
+    layerOver(layer: TElevatorLayer): TElevatorLayer;
+}

package/dist/adapter/elevator/scope.class.js

@@ -0,0 +1,31 @@
+import { TReactElevator } from "./elevator.class.js";
+//#region src/adapter/elevator/scope.class.ts
+var TReactElevatorScope = class {
+	parent;
+	_own = /* @__PURE__ */ new Map();
+	_reads = /* @__PURE__ */ new Map();
+	/** @param parent слой, который компонент увидел на рендере */
+	constructor(parent) {
+		this.parent = parent;
+	}
+	elevator = (key) => new TReactElevator(key.name, this);
+	read(key) {
+		const value = this.parent.get(key);
+		this._reads.set(key, value);
+		return value;
+	}
+	write(key, value) {
+		this._own.set(key, value);
+	}
+	isStale(layer) {
+		for (const [key, value] of this._reads) if (layer.get(key) !== value) return true;
+		return false;
+	}
+	/** Слой для детей; своего нет — тот же объект, детям не из-за чего перерисовываться. */
+	layerOver(layer) {
+		if (this._own.size === 0) return layer;
+		return new Map([...layer, ...this._own]);
+	}
+};
+//#endregion
+export { TReactElevatorScope };

package/dist/adapter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common';
+export * from './runtime';
+export * from './elevator';
+export * from './locale';
+export * from './toasts';

package/dist/adapter/locale/LocaleProvider.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+import type { TLocale } from '@soxa-ui/plugins';
+export type TLocaleProviderProps = {
+    /** Локаль поддерева: тег для Intl и строки библиотеки (`ruRU`, `extendLocale(...)`) */
+    locale: TLocale;
+    children?: ReactNode;
+};
+/**
+ * LocaleProvider — язык и строки библиотеки компонентам внутри; смена пропа
+ * переписывает их на лету, без перемонтирования. Без провайдера — английский.
+ * AGENTS.md (React), «Локаль и тосты».
+ *
+ * ```tsx
+ * <LocaleProvider locale={current}>
+ * 	<App />
+ * </LocaleProvider>
+ * ```
+ */
+export declare function LocaleProvider({ locale, children }: TLocaleProviderProps): ReactNode;

package/dist/adapter/locale/LocaleProvider.js

@@ -0,0 +1,29 @@
+"use client";
+import { LocaleContext } from "./context.js";
+import { jsx } from "react/jsx-runtime";
+import { useLayoutEffect, useState } from "react";
+import { TLocaleSource } from "@soxa-ui/plugins";
+//#region src/adapter/locale/LocaleProvider.tsx
+/**
+* LocaleProvider — язык и строки библиотеки компонентам внутри; смена пропа
+* переписывает их на лету, без перемонтирования. Без провайдера — английский.
+* AGENTS.md (React), «Локаль и тосты».
+*
+* ```tsx
+* <LocaleProvider locale={current}>
+* 	<App />
+* </LocaleProvider>
+* ```
+*/
+function LocaleProvider({ locale, children }) {
+	const [source] = useState(() => new TLocaleSource(locale));
+	useLayoutEffect(() => {
+		source.locale = locale;
+	}, [source, locale]);
+	return /* @__PURE__ */ jsx(LocaleContext, {
+		value: source,
+		children
+	});
+}
+//#endregion
+export { LocaleProvider };

package/dist/adapter/locale/context.d.ts

@@ -0,0 +1,3 @@
+import type { ILocaleSource } from '@soxa-ui/plugins';
+/** Источник локали ближайшего `LocaleProvider`; вне провайдера — `undefined`. */
+export declare const LocaleContext: import("react").Context<ILocaleSource | undefined>;

package/dist/adapter/locale/context.js

@@ -0,0 +1,7 @@
+"use client";
+import { createContext } from "react";
+//#region src/adapter/locale/context.ts
+/** Источник локали ближайшего `LocaleProvider`; вне провайдера — `undefined`. */
+var LocaleContext = createContext(void 0);
+//#endregion
+export { LocaleContext };

package/dist/adapter/locale/index.d.ts

@@ -0,0 +1,2 @@
+export { LocaleProvider } from './LocaleProvider';
+export type { TLocaleProviderProps } from './LocaleProvider';

package/dist/adapter/runtime/NativeInput.d.ts

@@ -0,0 +1,24 @@
+/**
+ * NativeInput — неуправляемый `<input>`, чьё живое состояние (текст, значение
+ * ползунка, отметку, «выбрано частично») ведёт ядро: аналог `:value`,
+ * `:checked`, `:indeterminate` у Vue. AGENTS.md (React), «Поля ввода».
+ */
+import type { InputHTMLAttributes, ReactElement } from 'react';
+/** Живое состояние поля: свойства узла, которые ведёт ядро. */
+export type TNativeInputLive = {
+    /** Текст текстового поля или значение ползунка (`type="range"`). */
+    readonly value?: string | number;
+    /** Отметка флажка и радио. */
+    readonly checked?: boolean;
+    /** «Выбрано частично» у флажка. */
+    readonly indeterminate?: boolean;
+};
+/**
+ * Атрибуты `<input>` без живого состояния: `checked` атрибутом сделал бы поле
+ * контролируемым, а `value` у флажка и радио — значение для формы.
+ */
+export type TNativeInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'checked' | 'defaultChecked' | 'defaultValue'> & {
+    /** Состояние, которое ведёт ядро: ключа нет — свойство поле не трогает. */
+    live: TNativeInputLive;
+};
+export declare function NativeInput({ live, ...attributes }: TNativeInputProps): ReactElement;

package/dist/adapter/runtime/NativeInput.js

@@ -0,0 +1,40 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useLayoutEffect, useRef } from "react";
+//#region src/adapter/runtime/NativeInput.tsx
+/**
+* NativeInput — неуправляемый `<input>`, чьё живое состояние (текст, значение
+* ползунка, отметку, «выбрано частично») ведёт ядро: аналог `:value`,
+* `:checked`, `:indeterminate` у Vue. AGENTS.md (React), «Поля ввода».
+*/
+function toProperties(live) {
+	return {
+		value: "value" in live ? String(live.value ?? "") : void 0,
+		checked: "checked" in live ? live.checked === true : void 0,
+		indeterminate: "indeterminate" in live ? live.indeterminate === true : void 0
+	};
+}
+function NativeInput({ live, ...attributes }) {
+	const node = useRef(null);
+	const { value, checked, indeterminate } = toProperties(live);
+	const initial = useRef(value);
+	useLayoutEffect(() => {
+		const input = node.current;
+		if (!input) return;
+		if (value !== void 0 && input.value !== value) input.value = value;
+		if (checked !== void 0) input.checked = checked;
+		if (indeterminate !== void 0 && input.indeterminate !== indeterminate) input.indeterminate = indeterminate;
+	}, [
+		value,
+		checked,
+		indeterminate
+	]);
+	return /* @__PURE__ */ jsx("input", {
+		...attributes,
+		ref: node,
+		defaultValue: initial.current,
+		defaultChecked: checked
+	});
+}
+//#endregion
+export { NativeInput };

package/dist/adapter/runtime/NativeTextarea.d.ts

@@ -0,0 +1,10 @@
+/**
+ * NativeTextarea — неуправляемая `<textarea>`, чей текст ведёт ядро: то же,
+ * что `NativeInput`. AGENTS.md (React), «Поля ввода».
+ */
+import type { ReactElement, TextareaHTMLAttributes } from 'react';
+export type TNativeTextareaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'value' | 'defaultValue'> & {
+    /** Текст, который ведёт ядро; `undefined` — пустое поле. */
+    text: string | undefined;
+};
+export declare function NativeTextarea({ text, ...attributes }: TNativeTextareaProps): ReactElement;

package/dist/adapter/runtime/NativeTextarea.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useLayoutEffect, useRef } from "react";
+//#region src/adapter/runtime/NativeTextarea.tsx
+/**
+* NativeTextarea — неуправляемая `<textarea>`, чей текст ведёт ядро: то же,
+* что `NativeInput`. AGENTS.md (React), «Поля ввода».
+*/
+function NativeTextarea({ text, ...attributes }) {
+	const node = useRef(null);
+	const value = text ?? "";
+	const initial = useRef(value);
+	useLayoutEffect(() => {
+		const textarea = node.current;
+		if (textarea && textarea.value !== value) textarea.value = value;
+	}, [value]);
+	return /* @__PURE__ */ jsx("textarea", {
+		...attributes,
+		ref: node,
+		defaultValue: initial.current
+	});
+}
+//#endregion
+export { NativeTextarea };

package/dist/adapter/runtime/Teleport.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Teleport — аналог `<teleport :to>` Vue: рисует содержимое в элементе по
+ * селектору цели. Контейнер портала — одна обёртка на всё монтирование, и
+ * двигается она, а не узлы React. AGENTS.md (React), «Teleport».
+ */
+import type { ReactNode } from 'react';
+export type TTeleportProps = {
+    /** Селектор цели: `body`, `#layers`. */
+    to: string | undefined;
+    /** Рисовать на месте, без портала */
+    disabled?: boolean;
+    children?: ReactNode;
+};
+export declare function Teleport({ to, disabled, children }: TTeleportProps): ReactNode;

package/dist/adapter/runtime/Teleport.js

@@ -0,0 +1,82 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useInsertionEffect, useState, useSyncExternalStore } from "react";
+import { createPortal } from "react-dom";
+//#region src/adapter/runtime/Teleport.tsx
+/**
+* Teleport — аналог `<teleport :to>` Vue: рисует содержимое в элементе по
+* селектору цели. Контейнер портала — одна обёртка на всё монтирование, и
+* двигается она, а не узлы React. AGENTS.md (React), «Teleport».
+*/
+var subscribe = () => () => {};
+var onClient = () => true;
+var onServer = () => false;
+/** Стиль обёртки и узла места: своей коробки у них нет. */
+var CONTENTS = { display: "contents" };
+/** Ключ портала — один на все рендеры: узел места рядом его не сдвинет. */
+var PORTAL_KEY = "teleport";
+function targetOf(selector) {
+	return selector ? document.querySelector(selector) : null;
+}
+function advance(phase, client, disabled, target) {
+	if (phase === "wrapped") return phase;
+	if (!client) return disabled ? "placed" : phase;
+	if (phase === "placed") return disabled ? phase : "wrapped";
+	return disabled || target ? "wrapped" : phase;
+}
+/**
+* Обёртка и её место: цель, куда её положил insertion-эффект, или узел места,
+* куда её положил его ref.
+*/
+var TTeleportWrapper = class {
+	/** Заводится на клиенте, когда впервые нужна. */
+	_node = null;
+	_target = null;
+	_place = null;
+	get node() {
+		if (!this._node) {
+			this._node = document.createElement("div");
+			this._node.style.display = "contents";
+		}
+		return this._node;
+	}
+	/** Обёртку — в цель; цели нет — эффект её не трогает, очистки нет. */
+	enter(target) {
+		if (!target) return void 0;
+		target.appendChild(this.node);
+		this._target = target;
+		return this.leave;
+	}
+	leave = () => {
+		this._takeFrom(this._target);
+		this._target = null;
+	};
+	/** Ref узла места: обёртку — в него, при снятии — вон из него. */
+	place = (node) => {
+		if (node) node.appendChild(this.node);
+		else this._takeFrom(this._place);
+		this._place = node;
+	};
+	_takeFrom(parent) {
+		const node = this._node;
+		if (node && parent && node.parentNode === parent) node.remove();
+	}
+};
+function Teleport({ to, disabled = false, children }) {
+	const client = useSyncExternalStore(subscribe, onClient, onServer);
+	const [wrapper] = useState(() => new TTeleportWrapper());
+	const target = client && !disabled ? targetOf(to) : null;
+	const [stored, setPhase] = useState(() => advance("none", client, disabled, target));
+	const phase = advance(stored, client, disabled, target);
+	if (phase !== stored) setPhase(phase);
+	const into = phase === "wrapped" ? target : null;
+	useInsertionEffect(() => wrapper.enter(into), [wrapper, into]);
+	if (phase === "none") return null;
+	if (phase === "placed") return children;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [disabled ? /* @__PURE__ */ jsx("div", {
+		ref: wrapper.place,
+		style: CONTENTS
+	}) : null, createPortal(children, wrapper.node, PORTAL_KEY)] });
+}
+//#endregion
+export { Teleport };

package/dist/adapter/runtime/accepting.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The contexts being accepted right now, only while `TBuilt.accept` runs. The
+ * consumer's sink of such a context drops its events (`TEventCallbacks`):
+ * what the acceptance writes is the starting state.
+ */
+import type { IAdapterContext } from '@soxa-ui/setup';
+/** Run the acceptance of the contexts with their consumers silent. */
+export declare function accepting(contexts: IAdapterContext | readonly IAdapterContext[], accept: () => void): void;
+/** Whether the context is being accepted right now. */
+export declare function isAccepting(context: IAdapterContext): boolean;

package/dist/adapter/runtime/accepting.js

@@ -0,0 +1,18 @@
+//#region src/adapter/runtime/accepting.ts
+var now = /* @__PURE__ */ new Set();
+/** Run the acceptance of the contexts with their consumers silent. */
+function accepting(contexts, accept) {
+	const list = Array.isArray(contexts) ? contexts : [contexts];
+	for (const context of list) now.add(context);
+	try {
+		accept();
+	} finally {
+		for (const context of list) now.delete(context);
+	}
+}
+/** Whether the context is being accepted right now. */
+function isAccepting(context) {
+	return now.has(context);
+}
+//#endregion
+export { accepting, isAccepting };

package/dist/adapter/runtime/click-action.class.d.ts

@@ -0,0 +1,14 @@
+/**
+ * TClickAction — the action of a part on a click, as a native listener on the
+ * node: AGENTS.md (React), «Клик части». A class, not a closure:
+ * AGENTS.md (React), «Функции дольше рендера — в классах».
+ */
+export declare class TClickAction {
+    private _action;
+    private _node;
+    /** The action of the last render. */
+    update(action: (event: Event) => void): void;
+    /** The ref of the node: the listener moves with the node. */
+    readonly ref: (node: Element | null) => void;
+    private readonly _listener;
+}

package/dist/adapter/runtime/click-action.class.js

@@ -0,0 +1,26 @@
+//#region src/adapter/runtime/click-action.class.ts
+/**
+* TClickAction — the action of a part on a click, as a native listener on the
+* node: AGENTS.md (React), «Клик части». A class, not a closure:
+* AGENTS.md (React), «Функции дольше рендера — в классах».
+*/
+var TClickAction = class {
+	_action = () => {};
+	_node = null;
+	/** The action of the last render. */
+	update(action) {
+		this._action = action;
+	}
+	/** The ref of the node: the listener moves with the node. */
+	ref = (node) => {
+		if (node === this._node) return;
+		this._node?.removeEventListener("click", this._listener);
+		this._node = node;
+		node?.addEventListener("click", this._listener);
+	};
+	_listener = (event) => {
+		this._action(event);
+	};
+};
+//#endregion
+export { TClickAction };

package/dist/adapter/runtime/drafts.class.d.ts

@@ -0,0 +1,24 @@
+/**
+ * TDrafts — сборки, которые React ещё не принял, и освобождение тех, что он
+ * отбросил. AGENTS.md (React), «Срок жизни контекста».
+ *
+ * 1. `take(options)` — до сборки контекста: уничтожает непринятую сборку с
+ *    тем же `ctrl` или движком и отдаёт взятое;
+ * 2. `add(held, destroy)` — собранное становится черновиком;
+ * 3. `accept(held)` при коммите — больше не черновик.
+ */
+import type { IAdapterContextOptions } from '@soxa-ui/setup';
+export type TTaken = {
+    readonly held: object[];
+    readonly mountId?: string;
+};
+export declare class TDrafts {
+    /** Непринятые сборки — по каждому объекту, который они взяли снаружи. */
+    private readonly _drafts;
+    /** Взятое снаружи — `ctrl` и движок фасада; id — выброшенного черновика того же `ctrl`. */
+    take(options: IAdapterContextOptions): TTaken;
+    add(held: readonly object[], destroy: () => void, mountId: string): void;
+    accept(held: readonly object[]): void;
+    private _discard;
+    private _forget;
+}

package/dist/adapter/runtime/drafts.class.js

@@ -0,0 +1,41 @@
+//#region src/adapter/runtime/drafts.class.ts
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+var TDrafts = class {
+	/** Непринятые сборки — по каждому объекту, который они взяли снаружи. */
+	_drafts = /* @__PURE__ */ new WeakMap();
+	/** Взятое снаружи — `ctrl` и движок фасада; id — выброшенного черновика того же `ctrl`. */
+	take(options) {
+		const engine = options.options ? Reflect.get(options.options, "engine") : void 0;
+		const held = [options.ctrl, engine].filter(isObject);
+		const mountId = options.ctrl ? this._drafts.get(options.ctrl)?.mountId : void 0;
+		for (const value of held) this._discard(value);
+		return {
+			held,
+			mountId
+		};
+	}
+	add(held, destroy, mountId) {
+		const draft = {
+			held,
+			destroy,
+			mountId
+		};
+		for (const value of held) this._drafts.set(value, draft);
+	}
+	accept(held) {
+		this._forget(held);
+	}
+	_discard(value) {
+		const draft = this._drafts.get(value);
+		if (draft === void 0) return;
+		this._forget(draft.held);
+		draft.destroy();
+	}
+	_forget(held) {
+		for (const value of held) if (this._drafts.get(value)?.held === held) this._drafts.delete(value);
+	}
+};
+//#endregion
+export { TDrafts };

package/dist/adapter/runtime/event-callbacks.class.d.ts

@@ -0,0 +1,29 @@
+/**
+ * TEventCallbacks — the binding's event sink: an event goes to the callback
+ * prop of the same name from the last render's props. A class, not a closure:
+ * AGENTS.md (React), «Функции дольше рендера — в классах».
+ */
+import type { IAdapterContext, TEventSink, TExchange } from '@soxa-ui/setup';
+export declare class TEventCallbacks {
+    private readonly _adapter;
+    private _props;
+    /** The subscription of the last `listen`. */
+    private _stop?;
+    /** @param _adapter the context whose events the sink takes */
+    constructor(_adapter: IAdapterContext);
+    update(props: object): void;
+    readonly sink: TEventSink;
+    /**
+     * Listen to the binding until the context's `detach`, which comes from the
+     * teardown's first moment or, for a collection item, from its collection.
+     * Returns the layout effect's cleanup (`release`).
+     */
+    listen(binding: TExchange): () => void;
+    /**
+     * The layout effect's cleanup is the teardown's first moment: React runs
+     * every layout cleanup of a removed subtree before any passive one, and the
+     * destruction is a passive cleanup (`useAdapterContext`). So it ends the
+     * subscription and detaches the context.
+     */
+    readonly release: () => void;
+}

package/dist/adapter/runtime/event-callbacks.class.js

@@ -0,0 +1,44 @@
+import { isAccepting } from "./accepting.js";
+//#region src/adapter/runtime/event-callbacks.class.ts
+var TEventCallbacks = class {
+	_adapter;
+	_props = {};
+	/** The subscription of the last `listen`. */
+	_stop;
+	/** @param _adapter the context whose events the sink takes */
+	constructor(_adapter) {
+		this._adapter = _adapter;
+	}
+	update(props) {
+		this._props = props;
+	}
+	sink = (name, args) => {
+		if (isAccepting(this._adapter)) return;
+		const callback = Reflect.get(this._props, name);
+		if (typeof callback === "function") callback(...args);
+	};
+	/**
+	* Listen to the binding until the context's `detach`, which comes from the
+	* teardown's first moment or, for a collection item, from its collection.
+	* Returns the layout effect's cleanup (`release`).
+	*/
+	listen(binding) {
+		const stop = binding.events.listen(this.sink);
+		this._stop = stop;
+		this._adapter.events.on("detach", stop);
+		return this.release;
+	}
+	/**
+	* The layout effect's cleanup is the teardown's first moment: React runs
+	* every layout cleanup of a removed subtree before any passive one, and the
+	* destruction is a passive cleanup (`useAdapterContext`). So it ends the
+	* subscription and detaches the context.
+	*/
+	release = () => {
+		this._stop?.();
+		this._stop = void 0;
+		this._adapter.detach();
+	};
+};
+//#endregion
+export { TEventCallbacks };

package/dist/adapter/runtime/index.d.ts

@@ -0,0 +1,16 @@
+export { useAdapter, useCollectionAdapter } from './useAdapter';
+export { useAdapterContext } from './useAdapterContext';
+export { useComponent } from './useComponent';
+export { useRootElement } from './useRootElement';
+export { useClickAction } from './useClickAction';
+export { withRenderBoundary } from './withRenderBoundary';
+export { Teleport } from './Teleport';
+export { NativeInput } from './NativeInput';
+export { NativeTextarea } from './NativeTextarea';
+export type { TBinding, TCollectionBinding } from './useAdapter';
+export type { TConsumerRef, TRootSource } from './root-ref.class';
+export type { TAdapterContexts, TAssembly, TCreateAdapterContext } from './useAdapterContext';
+export type { TComponentBinding } from './useComponent';
+export type { TTeleportProps } from './Teleport';
+export type { TNativeInputLive, TNativeInputProps } from './NativeInput';
+export type { TNativeTextareaProps } from './NativeTextarea';

package/dist/adapter/runtime/root-ref.class.d.ts

@@ -0,0 +1,39 @@
+/**
+ * TRootRef — ref корня компонента: узел привязывается к `TElementPlugin`
+ * контекста, и тот же узел получает `ref` потребителя; корень значением —
+ * подпиской (`TRootSource`). AGENTS.md (React), «Корень и `ref` потребителя».
+ */
+import type { Ref } from 'react';
+import type { IAdapterContext } from '@soxa-ui/setup';
+/** `ref` потребителя. Узел — `Element`: `tag` свободен, корнем бывает `<svg>`. */
+export type TConsumerRef = Ref<Element> | undefined;
+/** Корень значением — подписка и снимок, как их ждёт `useSyncExternalStore`. */
+export type TRootSource = {
+    readonly subscribe: (listener: () => void) => () => void;
+    /** Корень сейчас: до коммита, после снятия и у уничтоженного — `null`. */
+    readonly getSnapshot: () => Element | null;
+};
+/** `ref` потребителя из пропсов: в React 19 это обычный проп. */
+export declare function consumerRefOf(props: object): TConsumerRef;
+export declare class TRootRef implements TRootSource {
+    /** Контекст корня; уничтожен — `null`, и ref больше ничего не делает. */
+    private _context;
+    private _node;
+    /** `ref` потребителя последнего коммита. */
+    private _consumer;
+    private _given;
+    /** Заводятся с первым подписчиком — у большинства компонентов их нет. */
+    private _listeners;
+    constructor(adapter: IAdapterContext);
+    /** Ref корня: привязка к `TElementPlugin`, затем тот же узел — `ref` потребителя. */
+    readonly attach: (element: Element | null) => void;
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly getSnapshot: () => Element | null;
+    /** Ref корня внутри обёртки: только привязка — `ref` потребителя получает обёртка. */
+    readonly bind: (element: Element | null) => void;
+    /** `ref` потребителя коммита — раньше, чем React привяжет ref узлов. */
+    consume(ref: TConsumerRef): void;
+    /** Сменился узел или `ref` потребителя: прежнему — отпустить, новому — отдать. */
+    sync(): void;
+    private _destroy;
+}