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

package/dist/adapter/runtime/root-ref.class.js

@@ -0,0 +1,86 @@
+//#region src/adapter/runtime/root-ref.class.ts
+var unsubscribed = () => {};
+function isConsumerRef(value) {
+	return typeof value === "function" || typeof value === "object" && value !== null && "current" in value;
+}
+/** `ref` потребителя из пропсов: в React 19 это обычный проп. */
+function consumerRefOf(props) {
+	const ref = Reflect.get(props, "ref");
+	return isConsumerRef(ref) ? ref : void 0;
+}
+/** Отдать узел `ref` так, как отдал бы React, и вернуть, как его отпустить. */
+function give(ref, node) {
+	if (typeof ref === "function") {
+		const cleanup = ref(node);
+		return typeof cleanup === "function" ? cleanup : () => ref(null);
+	}
+	ref.current = node;
+	return () => {
+		ref.current = null;
+	};
+}
+var TRootRef = class {
+	/** Контекст корня; уничтожен — `null`, и ref больше ничего не делает. */
+	_context;
+	_node = null;
+	/** `ref` потребителя последнего коммита. */
+	_consumer = void 0;
+	_given = null;
+	/** Заводятся с первым подписчиком — у большинства компонентов их нет. */
+	_listeners = null;
+	constructor(adapter) {
+		this._context = adapter;
+		adapter.events.listen((event) => {
+			if (event === "destroy") this._destroy();
+		});
+	}
+	/** Ref корня: привязка к `TElementPlugin`, затем тот же узел — `ref` потребителя. */
+	attach = (element) => {
+		if (!this._context) return;
+		const changed = element !== this._node;
+		this._context.bindElement(element);
+		this._node = element;
+		this.sync();
+		if (changed) this._listeners?.forEach((listener) => listener());
+	};
+	subscribe = (listener) => {
+		if (!this._context) return unsubscribed;
+		this._listeners ??= /* @__PURE__ */ new Set();
+		this._listeners.add(listener);
+		return () => {
+			this._listeners?.delete(listener);
+		};
+	};
+	getSnapshot = () => this._node;
+	/** Ref корня внутри обёртки: только привязка — `ref` потребителя получает обёртка. */
+	bind = (element) => {
+		this._context?.bindElement(element);
+	};
+	/** `ref` потребителя коммита — раньше, чем React привяжет ref узлов. */
+	consume(ref) {
+		if (this._context) this._consumer = ref;
+	}
+	/** Сменился узел или `ref` потребителя: прежнему — отпустить, новому — отдать. */
+	sync() {
+		const node = this._node;
+		const ref = this._consumer;
+		const given = this._given;
+		if (given && given.ref === ref && given.node === node) return;
+		this._given = null;
+		given?.release();
+		if (node && ref) this._given = {
+			ref,
+			node,
+			release: give(ref, node)
+		};
+	}
+	_destroy() {
+		this._context = null;
+		this._node = null;
+		this._consumer = void 0;
+		this._listeners = null;
+		this.sync();
+	}
+};
+//#endregion
+export { TRootRef, consumerRefOf };

package/dist/adapter/runtime/stable-snapshot.class.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TStableSnapshot — снимок связки, где значение, не сменившееся по
+ * содержимому, остаётся прежним объектом. AGENTS.md (React), «Связка и
+ * состояние».
+ *
+ * Он же отдаёт `useSyncExternalStore` подписку на состояние: обоим нужны
+ * функции без `this`, а у состояния обмена это методы — привязывает их тот,
+ * кому они нужны так.
+ */
+import type { TStateSnapshot, TStateStore } from '@soxa-ui/setup';
+export declare class TStableSnapshot {
+    private readonly _state;
+    /** Снимок связки, из которого собран `_snapshot`. */
+    private _source;
+    private _snapshot;
+    constructor(_state: Pick<TStateStore, 'getSnapshot' | 'subscribe'>);
+    readonly subscribe: (onChange: () => void) => (() => void);
+    readonly getSnapshot: () => TStateSnapshot;
+    private _settle;
+}

package/dist/adapter/runtime/stable-snapshot.class.js

@@ -0,0 +1,43 @@
+//#region src/adapter/runtime/stable-snapshot.class.ts
+function isPlain(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/** Простые объекты и массивы — вглубь, остальное — по идентичности. */
+function sameContent(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, index) => sameContent(item, b[index]));
+	if (Array.isArray(a) || Array.isArray(b) || !isPlain(a) || !isPlain(b)) return false;
+	const keys = Object.keys(a);
+	return keys.length === Object.keys(b).length && keys.every((key) => key in b && sameContent(Reflect.get(a, key), Reflect.get(b, key)));
+}
+var TStableSnapshot = class {
+	_state;
+	/** Снимок связки, из которого собран `_snapshot`. */
+	_source = null;
+	_snapshot = null;
+	constructor(_state) {
+		this._state = _state;
+	}
+	subscribe = (onChange) => this._state.subscribe(onChange);
+	getSnapshot = () => {
+		const source = this._state.getSnapshot();
+		if (source === this._source && this._snapshot) return this._snapshot;
+		this._source = source;
+		this._snapshot = this._snapshot ? this._settle(this._snapshot, source) : source;
+		return this._snapshot;
+	};
+	_settle(previous, next) {
+		let changed = false;
+		const entries = Object.entries(next).map(([name, value]) => {
+			const kept = previous[name];
+			if (name in previous && sameContent(kept, value)) return [name, kept];
+			changed = true;
+			return [name, value];
+		});
+		return changed ? Object.freeze(Object.fromEntries(entries)) : previous;
+	}
+};
+//#endregion
+export { TStableSnapshot };

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

@@ -0,0 +1,39 @@
+/**
+ * useAdapter — связка adapter-context с React через обмен `adapter.connect()`:
+ * состояние — внешнее хранилище `useSyncExternalStore`, входы — эффектом,
+ * события — колбэкам-пропсам, корень — `TRootRef`.
+ * AGENTS.md (React), «Связка и состояние».
+ */
+import type { IAdapterContext, IComponentContract, TAdapterState } from '@soxa-ui/setup';
+import type { IPluginBundle } from '@soxa-ui/plugins';
+import { type TRootSource } from './root-ref.class';
+export type TBinding<C extends IComponentContract = IComponentContract, TProps extends object = object> = {
+    ctrl: C['instance'];
+    plugins: IPluginBundle | null;
+    /** Ref корня: привязка к `TElementPlugin`, и тот же узел — `ref` потребителя. */
+    ref: (el: Element | null) => void;
+    /** Ref корня внутри обёртки (`toWrappedRootProps`): только привязка. */
+    bindRef: (el: Element | null) => void;
+    /** Корень значением — для `useRootElement`. */
+    root: TRootSource;
+    /** Пропсы, которые компонент не съел: уходят атрибутами в DOM. */
+    forwardProps: Partial<TProps>;
+    state: TAdapterState<C>;
+};
+/** Связка, к которой добавляют фасад: компонента или уже с фасадом. */
+type TOwnerBinding<TProps extends object> = {
+    forwardProps: Partial<TProps>;
+    state: object;
+};
+/** Связка `TOwner` вместе с фасадом коллекции `F`: состояние обоих. */
+export type TCollectionBinding<TOwner extends TOwnerBinding<TProps>, F extends IComponentContract, TProps extends object> = Omit<TOwner, 'state'> & {
+    state: TOwner['state'] & TAdapterState<F>;
+};
+export declare function useAdapter<C extends IComponentContract, TProps extends object>(adapter: IAdapterContext<C>, props: TProps): TBinding<C, TProps>;
+/**
+ * Связка компонента вместе с фасадом его коллекции. `ctrl` и корень —
+ * компонента; фасад добавляет своё состояние и отбирает свои имена из того,
+ * что компонент не съел.
+ */
+export declare function useCollectionAdapter<TOwner extends TOwnerBinding<TProps>, F extends IComponentContract, TProps extends object>(owner: TOwner, facade: IAdapterContext<F>, props: TProps): TCollectionBinding<TOwner, F, TProps>;
+export {};

package/dist/adapter/runtime/useAdapter.js

@@ -0,0 +1,78 @@
+"use client";
+import { ReactProfile } from "../common/profile.js";
+import { TEventCallbacks } from "./event-callbacks.class.js";
+import { TRootRef, consumerRefOf } from "./root-ref.class.js";
+import { TStableSnapshot } from "./stable-snapshot.class.js";
+import { toInstanceState } from "@soxa-ui/setup";
+import { useEffect, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useSyncExternalStore } from "react";
+//#region src/adapter/runtime/useAdapter.ts
+/**
+* useAdapter — связка adapter-context с React через обмен `adapter.connect()`:
+* состояние — внешнее хранилище `useSyncExternalStore`, входы — эффектом,
+* события — колбэкам-пропсам, корень — `TRootRef`.
+* AGENTS.md (React), «Связка и состояние».
+*/
+function bind(adapter) {
+	const binding = adapter.connect(ReactProfile);
+	return {
+		adapter,
+		binding,
+		snapshot: new TStableSnapshot(binding.state),
+		callbacks: new TEventCallbacks(adapter)
+	};
+}
+function rebind(_, adapter) {
+	return bind(adapter);
+}
+/** Общее у компонента и фасада: состояние, входы и события. */
+function useExchange(adapter, props) {
+	const [store, dispatch] = useReducer(rebind, adapter, bind);
+	if (store.adapter !== adapter) dispatch(adapter);
+	const { binding, snapshot, callbacks } = store;
+	const state = useSyncExternalStore(snapshot.subscribe, snapshot.getSnapshot, snapshot.getSnapshot);
+	useEffect(() => {
+		binding.inputs.full(props);
+	}, [props, binding]);
+	callbacks.update(props);
+	useLayoutEffect(() => callbacks.listen(binding), [binding, callbacks]);
+	return {
+		binding,
+		state
+	};
+}
+function useAdapter(adapter, props) {
+	const { binding, state } = useExchange(adapter, props);
+	const root = useMemo(() => new TRootRef(adapter), [adapter]);
+	const consumer = consumerRefOf(props);
+	useInsertionEffect(() => root.consume(consumer), [root, consumer]);
+	useLayoutEffect(() => root.sync(), [root, consumer]);
+	const forwardProps = useMemo(() => binding.forward(props), [props, binding]);
+	return {
+		ctrl: adapter.instance,
+		plugins: adapter.bundle,
+		ref: root.attach,
+		bindRef: root.bind,
+		root,
+		forwardProps,
+		state: toInstanceState(state)
+	};
+}
+/**
+* Связка компонента вместе с фасадом его коллекции. `ctrl` и корень —
+* компонента; фасад добавляет своё состояние и отбирает свои имена из того,
+* что компонент не съел.
+*/
+function useCollectionAdapter(owner, facade, props) {
+	const { binding, state } = useExchange(facade, props);
+	const forwardProps = useMemo(() => binding.forward(owner.forwardProps), [owner.forwardProps, binding]);
+	return {
+		...owner,
+		forwardProps,
+		state: {
+			...owner.state,
+			...toInstanceState(state)
+		}
+	};
+}
+//#endregion
+export { useAdapter, useCollectionAdapter };

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

@@ -0,0 +1,22 @@
+/**
+ * useAdapterContext — keeps the component's contexts between renders and owns
+ * their whole life: assembly on the first render, acceptance at the commit,
+ * reassembly when the effect is set up again, destruction in its cleanup. The
+ * first moment of the teardown, `detach`, is the layout cleanup of the
+ * consumer's subscription (`TEventCallbacks.release`). AGENTS.md (React),
+ * «Срок жизни контекста».
+ */
+import { createAdapterContext } from '@soxa-ui/setup';
+import type { IAdapterContext, TElevatorFactory } from '@soxa-ui/setup';
+import { type TElevatorLayer } from '../elevator/layer';
+/** The context assembly the hook gives the factory: the signature of `createAdapterContext`. */
+export type TCreateAdapterContext = typeof createAdapterContext;
+/** What the factory assembles: the component's context, or several (its own and the facade's). */
+export type TAdapterContexts = IAdapterContext | readonly IAdapterContext[];
+export type TAssembly<T extends TAdapterContexts> = {
+    /** Exactly what the factory returned. */
+    readonly contexts: T;
+    /** The layer: the parent's plus what the assembly put down. Children get it via `Elevate`. */
+    readonly layer: TElevatorLayer;
+};
+export declare function useAdapterContext<T extends TAdapterContexts>(factory: (create: TCreateAdapterContext, elevator: TElevatorFactory) => T): TAssembly<T>;

package/dist/adapter/runtime/useAdapterContext.js

@@ -0,0 +1,128 @@
+"use client";
+import { accepting } from "./accepting.js";
+import { ElevatorContext } from "../elevator/layer.js";
+import { LocaleContext } from "../locale/context.js";
+import { TReactElevatorScope } from "../elevator/scope.class.js";
+import { TDrafts } from "./drafts.class.js";
+import { createAdapterContext } from "@soxa-ui/setup";
+import { useContext, useEffect, useEffectEvent, useId, useMemo, useReducer, useRef } from "react";
+//#region src/adapter/runtime/useAdapterContext.ts
+/**
+* useAdapterContext — keeps the component's contexts between renders and owns
+* their whole life: assembly on the first render, acceptance at the commit,
+* reassembly when the effect is set up again, destruction in its cleanup. The
+* first moment of the teardown, `detach`, is the layout cleanup of the
+* consumer's subscription (`TEventCallbacks.release`). AGENTS.md (React),
+* «Срок жизни контекста».
+*/
+var nextVersion = (version) => version + 1;
+/** Assemblies React has not accepted yet, shared by all components. */
+var drafts = new TDrafts();
+function isList(contexts) {
+	return Array.isArray(contexts);
+}
+function listOf(contexts) {
+	return isList(contexts) ? contexts : [contexts];
+}
+/** In assembly order: the facade is assembled on the owner's bundle and accepted after it. */
+function attachAll(contexts) {
+	for (const context of listOf(contexts)) context.attach();
+}
+/** All before any is destroyed: the component's consumer hears nothing of its facade leaving. */
+function detachAll(contexts) {
+	for (const context of listOf(contexts)) context.detach();
+}
+/** Detached, then in reverse order: the facade goes before the owner. */
+function destroyAll(contexts) {
+	detachAll(contexts);
+	for (const context of [...listOf(contexts)].reverse()) context.destroy();
+}
+/**
+* The assembly the hook holds: the contexts, the elevator and what they took
+* from outside. The effect's cleanup is the `destroy` arrow: AGENTS.md
+* (React), «Функции дольше рендера — в классах».
+*/
+var TBuilt = class {
+	contexts;
+	scope;
+	held;
+	_destroyed = false;
+	/**
+	* @param contexts exactly what the factory returned
+	* @param scope the elevator the contexts are assembled on
+	* @param held `ctrl` and the collection engine that came from outside
+	*/
+	constructor(contexts, scope, held) {
+		this.contexts = contexts;
+		this.scope = scope;
+		this.held = held;
+	}
+	get destroyed() {
+		return this._destroyed;
+	}
+	/**
+	* The consumers of the contexts being accepted hear nothing of what the
+	* acceptance writes (an item entering its collection): that is the
+	* starting state, as in the other adapters, where the consumer starts
+	* listening after the acceptance. React accepts in a passive effect, after
+	* the consumer started listening in a layout effect (before the first
+	* paint, so `ready` of `TElementPlugin` is not lost), and accepts the
+	* children before the owner, whose consumer has to hear them enter.
+	*/
+	accept() {
+		drafts.accept(this.held);
+		accepting(this.contexts, () => attachAll(this.contexts));
+	}
+	destroy = () => {
+		destroyAll(this.contexts);
+		this._destroyed = true;
+	};
+};
+function useAdapterContext(factory) {
+	const mountId = useId();
+	const locale = useContext(LocaleContext);
+	const parent = useContext(ElevatorContext);
+	const ref = useRef(null);
+	const settled = useRef(null);
+	const [, rerender] = useReducer(nextVersion, 0);
+	const assemble = (layer) => {
+		const scope = new TReactElevatorScope(layer);
+		const held = [];
+		let id = mountId;
+		const create = (descriptor, options, config) => {
+			const taken = drafts.take(options);
+			held.push(...taken.held);
+			id = taken.mountId ?? id;
+			return createAdapterContext(descriptor, {
+				mountId: id,
+				locale,
+				...options
+			}, config);
+		};
+		const built = new TBuilt(factory(create, scope.elevator), scope, held);
+		drafts.add(held, built.destroy, id);
+		return built;
+	};
+	const rebuild = useEffectEvent(() => assemble(parent));
+	if (!ref.current) ref.current = assemble(parent);
+	const built = ref.current;
+	const source = built.scope.isStale(parent) ? parent : settled.current;
+	useEffect(() => {
+		settled.current = source;
+		if (ref.current?.destroyed) {
+			ref.current = rebuild();
+			rerender();
+		}
+		const current = ref.current;
+		if (!current) return;
+		current.accept();
+		return current.destroy;
+	}, [source]);
+	const layer = useMemo(() => built.scope.layerOver(parent), [built, parent]);
+	return {
+		contexts: built.contexts,
+		layer
+	};
+}
+//#endregion
+export { useAdapterContext };

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

@@ -0,0 +1,6 @@
+/**
+ * useClickAction — the action of a part on a click (activate a tab, choose an
+ * option, close a panel): a ref for the part's node.
+ * AGENTS.md (React), «Клик части».
+ */
+export declare function useClickAction(action: (event: Event) => void): (node: Element | null) => void;

package/dist/adapter/runtime/useClickAction.js

@@ -0,0 +1,16 @@
+"use client";
+import { TClickAction } from "./click-action.class.js";
+import { useState } from "react";
+//#region src/adapter/runtime/useClickAction.ts
+/**
+* useClickAction — the action of a part on a click (activate a tab, choose an
+* option, close a panel): a ref for the part's node.
+* AGENTS.md (React), «Клик части».
+*/
+function useClickAction(action) {
+	const [click] = useState(() => new TClickAction());
+	click.update(action);
+	return click.ref;
+}
+//#endregion
+export { useClickAction };

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

@@ -0,0 +1,15 @@
+/**
+ * useComponent — сборка компонента с одним контекстом: держит его
+ * `useAdapterContext` и связывает `useAdapter`. Фабрика собирает контекст в
+ * месте вызова (`create(XDescriptor(), …)`, расширения — `.use(...)`): там
+ * выводится тип связки. Слой лифта — `layer`, детям его отдаёт `Elevate`.
+ */
+import type { IAdapterContext, IComponentContract, TElevatorFactory } from '@soxa-ui/setup';
+import type { TElevatorLayer } from '../elevator/layer';
+import { type TBinding } from './useAdapter';
+import { type TCreateAdapterContext } from './useAdapterContext';
+export type TComponentBinding<C extends IComponentContract, TProps extends object> = TBinding<C, TProps> & {
+    /** Слой лифта компонента: родительский и то, что опустили расширения. */
+    layer: TElevatorLayer;
+};
+export declare function useComponent<C extends IComponentContract, TProps extends object>(factory: (create: TCreateAdapterContext, elevator: TElevatorFactory) => IAdapterContext<C>, props: TProps): TComponentBinding<C, TProps>;

package/dist/adapter/runtime/useComponent.js

@@ -0,0 +1,13 @@
+"use client";
+import { useAdapter } from "./useAdapter.js";
+import { useAdapterContext } from "./useAdapterContext.js";
+//#region src/adapter/runtime/useComponent.ts
+function useComponent(factory, props) {
+	const { contexts, layer } = useAdapterContext(factory);
+	return {
+		...useAdapter(contexts, props),
+		layer
+	};
+}
+//#endregion
+export { useComponent };

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

@@ -0,0 +1,6 @@
+/**
+ * useRootElement — корень компонента значением рендера: `null` на сервере и до
+ * коммита, узел — после. AGENTS.md (React), «Корень и `ref` потребителя».
+ */
+import type { TRootSource } from './root-ref.class';
+export declare function useRootElement(source: TRootSource): Element | null;

package/dist/adapter/runtime/useRootElement.js

@@ -0,0 +1,13 @@
+"use client";
+import { useSyncExternalStore } from "react";
+//#region src/adapter/runtime/useRootElement.ts
+/**
+* useRootElement — корень компонента значением рендера: `null` на сервере и до
+* коммита, узел — после. AGENTS.md (React), «Корень и `ref` потребителя».
+*/
+var onServer = () => null;
+function useRootElement(source) {
+	return useSyncExternalStore(source.subscribe, source.getSnapshot, onServer);
+}
+//#endregion
+export { useRootElement };

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

@@ -0,0 +1,7 @@
+/**
+ * withRenderBoundary — граница перерисовки (`memo`): родитель перерисовывает
+ * компонент, только когда сменился проп по идентичности. AGENTS.md (React),
+ * «Связка и состояние».
+ */
+import type { FunctionComponent, NamedExoticComponent } from 'react';
+export declare function withRenderBoundary<TProps extends object>(component: FunctionComponent<TProps>): NamedExoticComponent<TProps>;

package/dist/adapter/runtime/withRenderBoundary.js

@@ -0,0 +1,13 @@
+"use client";
+import { memo } from "react";
+//#region src/adapter/runtime/withRenderBoundary.ts
+/**
+* withRenderBoundary — граница перерисовки (`memo`): родитель перерисовывает
+* компонент, только когда сменился проп по идентичности. AGENTS.md (React),
+* «Связка и состояние».
+*/
+function withRenderBoundary(component) {
+	return memo(component);
+}
+//#endregion
+export { withRenderBoundary };

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

@@ -0,0 +1,3 @@
+export { useToasts } from './useToasts';
+export { isToastRender } from './render';
+export type { TToastRender } from './types';

package/dist/adapter/toasts/render.d.ts

@@ -0,0 +1,6 @@
+import type { TToastRender } from './types';
+/**
+ * Своё содержимое тоста — компонент React, а не готовый элемент и не строка:
+ * проп `toast` тост отдаёт ему сам. AGENTS.md (React), «Локаль и тосты».
+ */
+export declare function isToastRender(value: unknown): value is TToastRender;

package/dist/adapter/toasts/render.js

@@ -0,0 +1,17 @@
+//#region src/adapter/toasts/render.ts
+/** Метки объектов-компонентов React (`memo`, `forwardRef`, `lazy`) — протокол React, как у `react-is`. */
+var COMPONENT_OBJECTS = /* @__PURE__ */ new Set([
+	Symbol.for("react.memo"),
+	Symbol.for("react.forward_ref"),
+	Symbol.for("react.lazy")
+]);
+/**
+* Своё содержимое тоста — компонент React, а не готовый элемент и не строка:
+* проп `toast` тост отдаёт ему сам. AGENTS.md (React), «Локаль и тосты».
+*/
+function isToastRender(value) {
+	if (typeof value === "function") return true;
+	return typeof value === "object" && value !== null && "$$typeof" in value && COMPONENT_OBJECTS.has(value.$$typeof);
+}
+//#endregion
+export { isToastRender };

package/dist/adapter/toasts/types.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentType } from 'react';
+import type { IToastsItem } from '@soxa-ui/core';
+/** Своё содержимое тоста (`render`): компонент React с пропом `toast`. */
+export type TToastRender = ComponentType<{
+    toast: IToastsItem;
+}>;

package/dist/adapter/toasts/useToasts.d.ts

@@ -0,0 +1,8 @@
+import type { IToastsApi } from '@soxa-ui/core';
+import type { TToastRender } from './types';
+/**
+ * API тостов ближайшего `<Toasts>` выше по дереву: `const { show } = useToasts()`.
+ * Пересобранный менеджер — новый API, поэтому `show` — в зависимостях
+ * эффекта. AGENTS.md (React), «Локаль и тосты».
+ */
+export declare function useToasts(): IToastsApi<TToastRender>;

package/dist/adapter/toasts/useToasts.js

@@ -0,0 +1,19 @@
+"use client";
+import { ElevatorContext } from "../elevator/layer.js";
+import { TReactElevatorScope } from "../elevator/scope.class.js";
+import { TOASTS_ELEVATOR } from "@soxa-ui/setup";
+import { useContext } from "react";
+//#region src/adapter/toasts/useToasts.ts
+/**
+* API тостов ближайшего `<Toasts>` выше по дереву: `const { show } = useToasts()`.
+* Пересобранный менеджер — новый API, поэтому `show` — в зависимостях
+* эффекта. AGENTS.md (React), «Локаль и тосты».
+*/
+function useToasts() {
+	const layer = useContext(ElevatorContext);
+	const api = new TReactElevatorScope(layer).elevator(TOASTS_ELEVATOR).up();
+	if (!api) throw new Error("useToasts(): выше по дереву нет <Toasts>. Оберните приложение менеджером: <Toasts><App /></Toasts>");
+	return api;
+}
+//#endregion
+export { useToasts };

package/dist/components/accordion/Accordion.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from 'react';
+import type { AccordionProps } from './base.component';
+/**
+ * Accordion — the set of expanding sections; section slots — AGENTS.md
+ * (React), «Слоты».
+ *
+ * The item slots go to each section as the owner's own props, not already
+ * called: calling one here would build a new React element on every redraw
+ * of the owner, defeating the section's render boundary regardless of it —
+ * `memo` sees a new `children`/prop reference and redraws anyway. The
+ * section calls them itself, with its own `ctrl` in their scope, the item
+ * identity it already carries as a stable prop (AGENTS.md, Pitfalls).
+ */
+export declare function Accordion(props: AccordionProps): ReactElement | null;

package/dist/components/accordion/Accordion.js

@@ -0,0 +1,40 @@
+"use client";
+import { toRootProps } from "../../adapter/common/root.js";
+import { hasSlot, renderSlot } from "../../adapter/common/slots.js";
+import { Elevate } from "../../adapter/elevator/Elevate.js";
+import { AccordionItem } from "./item/Item.js";
+import { useSetupAccordion } from "./setup.component.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/accordion/Accordion.tsx
+/**
+* Accordion — the set of expanding sections; section slots — AGENTS.md
+* (React), «Слоты».
+*
+* The item slots go to each section as the owner's own props, not already
+* called: calling one here would build a new React element on every redraw
+* of the owner, defeating the section's render boundary regardless of it —
+* `memo` sees a new `children`/prop reference and redraws anyway. The
+* section calls them itself, with its own `ctrl` in their scope, the item
+* identity it already carries as a stable prop (AGENTS.md, Pitfalls).
+*/
+function Accordion(props) {
+	const { ref, forwardProps, state, layer } = useSetupAccordion(props);
+	const { rendered, shown, attrs } = state;
+	if (!rendered) return null;
+	return /* @__PURE__ */ jsx("div", {
+		...toRootProps(ref, state, [attrs], forwardProps),
+		children: /* @__PURE__ */ jsx(Elevate, {
+			layer,
+			children: hasSlot(props.children) ? renderSlot(props.children) : shown?.map((item) => /* @__PURE__ */ jsx(AccordionItem, {
+				ctrl: item,
+				"arrow-icon": props["item-arrow-icon"],
+				leading: props["item-leading"],
+				header: props.item,
+				trailing: props["item-trailing"],
+				children: props["item-content"]
+			}, item.uid))
+		})
+	});
+}
+//#endregion
+export { Accordion };

package/dist/components/accordion/base.component.d.ts

@@ -0,0 +1,6 @@
+import type { IAccordion } from '@soxa-ui/core';
+import type { AccordionCollectionDescriptor, AccordionDescriptor } from '@soxa-ui/setup';
+import type { EventProps, UseDomProps } from '../../types';
+/** События Accordion — свои и фасада коллекции. */
+export type AccordionEventProps = EventProps<typeof AccordionDescriptor> & EventProps<typeof AccordionCollectionDescriptor>;
+export type AccordionProps = UseDomProps<typeof AccordionDescriptor, IAccordion, AccordionEventProps>;