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

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

@@ -0,0 +1,74 @@
+/**
+ * useAdapter — binds an adapter context to Solid, the counterpart of Vue's
+ * `useAdapter`.
+ *
+ * - state is shallow, a signal per property read (`createShallowState`),
+ *   filled by the subscription to the binding;
+ * - inputs: an effect over all props, the binding writes the changed ones;
+ * - the component body runs once, on the server too: that is the acceptance
+ *   (`attach()`), and the cleanup is `onCleanup`;
+ * - events go to the `onXxx` callback props, after the acceptance, until
+ *   `detach`.
+ *
+ * The adapter's `ref` binds the root to `TElementPlugin` and hands the same
+ * node to the consumer's `ref`. A collection has two contexts: the facade is
+ * bound by `useCollectionAdapter`, before the component, and `joinBindings`
+ * joins it with the component's binding. AGENTS.md (Solid), «Связка».
+ */
+import { type Accessor } from 'solid-js';
+import type { IAdapterContext, IComponentContract, TAdapterState } from '@soxa-ui/setup';
+import { type TJoinedState } from './state';
+/**
+ * The consumer's `ref` gets the component's root: a function, or a variable
+ * the Solid compiler turns into one. The node is an `Element`: the root can be
+ * an `<svg>`.
+ */
+export type TConsumerRef = Element | ((element: Element) => void);
+export type TBinding<C extends IComponentContract = IComponentContract, TProps extends object = object> = {
+    readonly ctrl: C['instance'];
+    readonly state: TAdapterState<C>;
+    /** A memo: the attributes the binding did not take. */
+    forwardProps: () => Partial<TProps>;
+    /** The bound root; `null` unrendered or removed. The panel's anchor (`anchor_anchor`). */
+    rootElement: Accessor<Element | null>;
+    /** The root's callback ref: binds to `TElementPlugin`, then calls the consumer's `ref`. */
+    ref: (el: Element) => void;
+    /** Only the binding: for a root inside a wrapper (the table's window). */
+    bindRef: (el: Element) => void;
+    /** Only the consumer's `ref`: for the root's wrapper. */
+    consumerRef: (el: Element) => void;
+};
+/** The binding of a collection facade: it has no `ctrl` and no `ref` of its own. */
+export type TCollectionBinding<TState extends object, TProps extends object = object> = {
+    readonly state: TState;
+    /** The attributes the facade leaves; `joinBindings` passes it the component's rest. */
+    forward: (props: Partial<TProps>) => Partial<TProps>;
+};
+/** What `joinBindings` takes of a binding it joins the facades with. */
+type TJoinable<TProps extends object> = {
+    readonly state: object;
+    forwardProps: () => Partial<TProps>;
+};
+/** A component's binding joined with a facade: state as one view, attributes from the facade. */
+export type TJoinedBinding<TOwner extends TJoinable<TProps>, TFacadeState extends object, TProps extends object> = Omit<TOwner, 'state' | 'forwardProps'> & {
+    readonly state: TJoinedState<TOwner['state'], TFacadeState>;
+    forwardProps: () => Partial<TProps>;
+};
+export declare function useAdapter<C extends IComponentContract, TProps extends object>(adapter: IAdapterContext<C>, props: TProps): TBinding<C, TProps>;
+/**
+ * The adapter of a collection facade: the facade takes its inputs and events
+ * from `props` and leaves the attributes that are not its own (`forward`).
+ * No `ctrl` and no `ref`: `joinBindings` joins the facade with the
+ * component's binding. Bound before the component: the facade, accepted,
+ * writes into it, and that is its starting state.
+ */
+export declare function useCollectionAdapter<C extends IComponentContract, TProps extends object>(adapter: IAdapterContext<C>, props: TProps): TCollectionBinding<TAdapterState<C>, TProps>;
+/**
+ * The binding of a component with its facades — one, for the markup: the
+ * state of all of them as one view (`joinState`), the attributes of the last
+ * facade (each takes its own from the rest of the previous one, the first —
+ * from the component's), the rest — the component's.
+ */
+export declare function joinBindings<TProps extends object, TOwner extends TJoinable<TProps>, TFacade extends object>(owner: TOwner, facade: TCollectionBinding<TFacade, TProps>): TJoinedBinding<TOwner, TFacade, TProps>;
+export declare function joinBindings<TProps extends object, TOwner extends TJoinable<TProps>, TFacade extends object, TOwnerFacade extends object>(owner: TOwner, facade: TCollectionBinding<TFacade, TProps>, ownerFacade: TCollectionBinding<TOwnerFacade, TProps>): TJoinedBinding<TJoinedBinding<TOwner, TFacade, TProps>, TOwnerFacade, TProps>;
+export {};

package/dist/adapter/runtime/useAdapter.js

@@ -0,0 +1,110 @@
+import { SolidProfile } from "../common/profile.js";
+import { createShallowState, joinState } from "./state.js";
+import { toInstanceState } from "@soxa-ui/setup";
+import { createComputed, createEffect, createMemo, createSignal, getOwner, onCleanup, onMount, runWithOwner } from "solid-js";
+//#region src/adapter/runtime/useAdapter.ts
+/**
+* useAdapter — binds an adapter context to Solid, the counterpart of Vue's
+* `useAdapter`.
+*
+* - state is shallow, a signal per property read (`createShallowState`),
+*   filled by the subscription to the binding;
+* - inputs: an effect over all props, the binding writes the changed ones;
+* - the component body runs once, on the server too: that is the acceptance
+*   (`attach()`), and the cleanup is `onCleanup`;
+* - events go to the `onXxx` callback props, after the acceptance, until
+*   `detach`.
+*
+* The adapter's `ref` binds the root to `TElementPlugin` and hands the same
+* node to the consumer's `ref`. A collection has two contexts: the facade is
+* bound by `useCollectionAdapter`, before the component, and `joinBindings`
+* joins it with the component's binding. AGENTS.md (Solid), «Связка».
+*/
+/** What the component and a facade share: exchange, state, inputs, acceptance, events, cleanup. */
+function useExchange(adapter, props) {
+	const binding = adapter.connect(SolidProfile);
+	const [state, write, updates] = createShallowState();
+	onCleanup(binding.updates.listen(updates));
+	onCleanup(binding.state.subscribe(write));
+	createEffect(() => binding.inputs.full(props));
+	adapter.attach();
+	const stop = binding.events.listen((exportName, args) => {
+		const callback = Reflect.get(props, exportName);
+		if (typeof callback === "function") callback(...args);
+	});
+	adapter.events.on("detach", stop);
+	onCleanup(stop);
+	detachFirst(adapter);
+	onCleanup(() => adapter.destroy());
+	return {
+		binding,
+		state
+	};
+}
+/**
+* Sends `detach` at the teardown's first moment: the consumer hears nothing
+* from then on, as in the other adapters (benchmarks/parity/README.md). Solid
+* cleans an owner's computations first, the last made first, and its cleanups
+* after them, so the children (markup items leaving the collection with an
+* ever shorter list, the root's unbinding) went before `onCleanup` of the
+* component's body. A computation made on mount, when the children already
+* exist, is the owner's last one, and its cleanup is the first of the
+* teardown. Before the mount, and on the server, where effects do not run,
+* `onCleanup(stop)` unsubscribes and `destroy` detaches.
+*/
+function detachFirst(adapter) {
+	const owner = getOwner();
+	onMount(() => runWithOwner(owner, () => createComputed(() => onCleanup(() => adapter.detach()))));
+}
+function useAdapter(adapter, props) {
+	const { binding, state } = useExchange(adapter, props);
+	const forwardProps = createMemo(() => binding.forward(props));
+	const [rootElement, setRootElement] = createSignal(null);
+	const bindRef = (el) => {
+		adapter.bindElement(el);
+		setRootElement(el);
+		onCleanup(() => {
+			adapter.bindElement(null);
+			setRootElement(null);
+		});
+	};
+	const consumerRef = (el) => {
+		const consumer = Reflect.get(props, "ref");
+		if (typeof consumer === "function") consumer(el);
+	};
+	return {
+		ctrl: adapter.instance,
+		state: toInstanceState(state),
+		forwardProps,
+		rootElement,
+		bindRef,
+		consumerRef,
+		ref(el) {
+			bindRef(el);
+			consumerRef(el);
+		}
+	};
+}
+/**
+* The adapter of a collection facade: the facade takes its inputs and events
+* from `props` and leaves the attributes that are not its own (`forward`).
+* No `ctrl` and no `ref`: `joinBindings` joins the facade with the
+* component's binding. Bound before the component: the facade, accepted,
+* writes into it, and that is its starting state.
+*/
+function useCollectionAdapter(adapter, props) {
+	const { binding, state } = useExchange(adapter, props);
+	return {
+		state: toInstanceState(state),
+		forward: (rest) => binding.forward(rest)
+	};
+}
+function joinBindings(owner, ...facades) {
+	return {
+		...owner,
+		state: facades.reduce((state, facade) => joinState(state, facade.state), owner.state),
+		forwardProps: createMemo(() => facades.reduce((rest, facade) => facade.forward(rest), owner.forwardProps()))
+	};
+}
+//#endregion
+export { joinBindings, useAdapter, useCollectionAdapter };

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,3 @@
+import type { TToastRender } from './types';
+/** Своё содержимое тоста рисуется, только когда это компонент Solid — функция. */
+export declare function isToastRender(value: unknown): value is TToastRender;

package/dist/adapter/toasts/render.js

@@ -0,0 +1,7 @@
+//#region src/adapter/toasts/render.ts
+/** Своё содержимое тоста рисуется, только когда это компонент Solid — функция. */
+function isToastRender(value) {
+	return typeof value === "function";
+}
+//#endregion
+export { isToastRender };

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

@@ -0,0 +1,6 @@
+import type { Component } from 'solid-js';
+import type { IToastsItem } from '@soxa-ui/core';
+/** Своё содержимое тоста (`render`): компонент с пропом `toast`, чтобы закрыть его. */
+export type TToastRender = Component<{
+    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()`. Берётся
+ * лифтом из слоя, который компонент видит в теле, — поэтому зовётся в теле
+ * компонента под менеджером. Менеджера нет — ошибка, а не молчаливый `show`.
+ */
+export declare function useToasts(): IToastsApi<TToastRender>;

package/dist/adapter/toasts/useToasts.js

@@ -0,0 +1,15 @@
+import { useElevator } from "../elevator/useElevator.js";
+import { TOASTS_ELEVATOR } from "@soxa-ui/setup";
+//#region src/adapter/toasts/useToasts.ts
+/**
+* API тостов ближайшего `<Toasts>`: `const { show } = useToasts()`. Берётся
+* лифтом из слоя, который компонент видит в теле, — поэтому зовётся в теле
+* компонента под менеджером. Менеджера нет — ошибка, а не молчаливый `show`.
+*/
+function useToasts() {
+	const api = useElevator().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,4 @@
+import type { JSX } from 'solid-js';
+import type { AccordionProps } from './base.component';
+/** Набор раскрывающихся секций: секции — содержимое или `shown`. */
+export declare function Accordion(props: AccordionProps): JSX.Element;

package/dist/components/accordion/Accordion.js

@@ -0,0 +1,71 @@
+import { relaySlot, renderSlot } from "../../adapter/common/slots.js";
+import { For, Show } from "../../adapter/runtime/flow.js";
+import { ResolvedSlot } from "../../adapter/common/ResolvedSlot.js";
+import { createRootProps } from "../../adapter/common/root.js";
+import { Elevate } from "../../adapter/elevator/Elevate.js";
+import { AccordionItem } from "./item/Item.js";
+import { setupAccordion } from "./setup.component.js";
+import { createComponent, insert, mergeProps, spread, template, use } from "solid-js/web";
+//#region src/components/accordion/Accordion.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<div>`);
+/** Набор раскрывающихся секций: секции — содержимое или `shown`. */
+function Accordion(props) {
+	const binding = setupAccordion(props);
+	const state = binding.state;
+	const root = createRootProps(() => ({
+		state,
+		sets: [state.attrs],
+		forward: binding.forwardProps()
+	}));
+	return createComponent(Show, {
+		get when() {
+			return state.rendered;
+		},
+		get children() {
+			var _el$ = _tmpl$();
+			var _ref$ = binding.ref;
+			typeof _ref$ === "function" ? use(_ref$, _el$) : binding.ref = _el$;
+			spread(_el$, mergeProps(root), false, true);
+			insert(_el$, createComponent(Elevate, {
+				get layer() {
+					return binding.layer;
+				},
+				get children() {
+					return createComponent(ResolvedSlot, {
+						get content() {
+							return props.children;
+						},
+						get fallback() {
+							return createComponent(For, {
+								get each() {
+									return state.shown;
+								},
+								children: (item) => createComponent(AccordionItem, {
+									ctrl: item,
+									get ["arrow-icon"]() {
+										return renderSlot(props["item-arrow-icon"], { item });
+									},
+									get leading() {
+										return renderSlot(props["item-leading"], { item });
+									},
+									get header() {
+										return relaySlot(props.item, { item });
+									},
+									get trailing() {
+										return renderSlot(props["item-trailing"], { item });
+									},
+									get children() {
+										return renderSlot(props["item-content"], { item });
+									}
+								})
+							});
+						}
+					});
+				}
+			}));
+			return _el$;
+		}
+	});
+}
+//#endregion
+export { Accordion };

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

@@ -0,0 +1,7 @@
+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>;
+/** Пропсы Accordion; входы коллекции (`engine`, `items`, `mode`, `trackBy`) — в ядре. */
+export type AccordionProps = UseDomProps<typeof AccordionDescriptor, IAccordion, AccordionEventProps>;

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

@@ -0,0 +1,8 @@
+import { Accordion as AccordionComponent } from './Accordion';
+import { AccordionItem } from './item';
+export * from './base.component';
+export { setupAccordion } from './setup.component';
+export * from './item';
+export declare const Accordion: typeof AccordionComponent & {
+    Item: typeof AccordionItem;
+};

package/dist/components/accordion/index.js

@@ -0,0 +1,9 @@
+import "./item/setup.component.js";
+import { AccordionItem } from "./item/Item.js";
+import "./setup.component.js";
+import { Accordion as Accordion$1 } from "./Accordion.js";
+import { withParts } from "@soxa-ui/setup";
+//#region src/components/accordion/index.ts
+var Accordion = withParts(Accordion$1, { Item: AccordionItem });
+//#endregion
+export { Accordion };

package/dist/components/accordion/item/Item.d.ts

@@ -0,0 +1,7 @@
+import type { JSX } from 'solid-js';
+import type { AccordionItemProps } from './base.component';
+/**
+ * Секция: заголовок — Button с `aria`, панель — узел с набором `contentAria`. Класс
+ * стрелки — на обёртке, а не на иконке: тема поворачивает и подменённую слотом.
+ */
+export declare function AccordionItem(props: AccordionItemProps): JSX.Element;

package/dist/components/accordion/item/Item.js

@@ -0,0 +1,110 @@
+import { renderSlot, resolveSlot } from "../../../adapter/common/slots.js";
+import { Show } from "../../../adapter/runtime/flow.js";
+import { clickAction } from "../../../adapter/common/click-action.js";
+import { createPartProps, createRootProps, toControlAttrs, toRootForward } from "../../../adapter/common/root.js";
+import { roleIcon } from "../../../adapter/common/icon.js";
+import { Root } from "../../../adapter/runtime/Root.js";
+import { Button } from "../../button/Button.js";
+import { Icon } from "../../icon/Icon.js";
+import { setupAccordionItem } from "./setup.component.js";
+import { createComponent, insert, memo, mergeProps, spread, template } from "solid-js/web";
+//#region src/components/accordion/item/Item.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<span class=so-accordion-item__arrow>`);
+var _tmpl$2 = /*#__PURE__*/ template(`<div class=so-accordion-item__body><div class=so-accordion-item__content>`);
+/** Стрелка без слота — иконка по роли. */
+var ARROW = roleIcon("arrowRight");
+/**
+* Секция: заголовок — Button с `aria`, панель — узел с набором `contentAria`. Класс
+* стрелки — на обёртке, а не на иконке: тема поворачивает и подменённую слотом.
+*/
+function AccordionItem(props) {
+	const binding = setupAccordionItem(props);
+	const state = binding.state;
+	const context = binding.context;
+	const root = createRootProps(() => ({
+		state,
+		sets: [state.dataset, state.attrs],
+		forward: toRootForward(binding.forwardProps())
+	}));
+	const contentAria = createPartProps(() => state.contentAria);
+	const title = resolveSlot(() => props.header, () => ({
+		item: binding.ctrl,
+		text: state.text ?? "",
+		selected: state.selected ?? false
+	}));
+	const arrowIcon = resolveSlot(() => props["arrow-icon"], () => ({ item: binding.ctrl }));
+	/** The header's attributes: all of the consumer's but the class and the style. */
+	const header = () => toControlAttrs(binding.forwardProps());
+	const toggle = clickAction(() => context?.adapters.selection.toggle());
+	/** Стрелка стороны: слот, а без него — иконка, если стрелка на этой стороне. */
+	const arrow = (side, icon) => createComponent(Show, {
+		get when() {
+			return state.arrowPlacement === side;
+		},
+		get children() {
+			var _el$ = _tmpl$();
+			insert(_el$, () => icon() ?? createComponent(Icon, {
+				embedded: "accordion.arrow",
+				tag: ARROW,
+				get size() {
+					return state.size;
+				}
+			}));
+			return _el$;
+		}
+	});
+	return createComponent(Show, {
+		get when() {
+			return state.rendered;
+		},
+		get children() {
+			return createComponent(Root, {
+				get tag() {
+					return state.tag;
+				},
+				attributes: root,
+				ref(r$) {
+					var _ref$ = binding.ref;
+					typeof _ref$ === "function" ? _ref$(r$) : binding.ref = r$;
+				},
+				get children() {
+					return [createComponent(Button, mergeProps({
+						embedded: "accordion.header",
+						type: "button",
+						"class": "so-accordion-item__header",
+						get view() {
+							return state.view;
+						},
+						get disabled() {
+							return state.disabled;
+						},
+						get size() {
+							return state.size;
+						},
+						get variant() {
+							return state.variant;
+						}
+					}, () => state.aria, header, {
+						ref: toggle,
+						get leading() {
+							return [memo(() => arrow("start", arrowIcon)), memo(() => renderSlot(props.leading, { item: binding.ctrl }))];
+						},
+						get trailing() {
+							return [memo(() => renderSlot(props.trailing, { item: binding.ctrl })), memo(() => arrow("end", arrowIcon))];
+						},
+						get children() {
+							return title() ?? state.text;
+						}
+					})), (() => {
+						var _el$2 = _tmpl$2(), _el$3 = _el$2.firstChild;
+						spread(_el$3, mergeProps(contentAria), false, true);
+						insert(_el$3, () => renderSlot(props.children, { item: binding.ctrl }));
+						return _el$2;
+					})()];
+				}
+			});
+		}
+	});
+}
+//#endregion
+export { AccordionItem };

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

@@ -0,0 +1,9 @@
+import type { IAccordionItem } from '@soxa-ui/core';
+import type { AccordionCollectionItemDescriptor, AccordionItemDescriptor } from '@soxa-ui/setup';
+import type { EventProps, TDomAttributes, UseDomProps } from '../../../types';
+/** События секции — свои и фасада: раскрытость, порядок, вид. */
+export type AccordionItemEventProps = EventProps<typeof AccordionItemDescriptor> & EventProps<typeof AccordionCollectionItemDescriptor>;
+/** Атрибуты секции: класс и стиль — корню, остальное — заголовку. */
+export type AccordionItemAttributes = TDomAttributes<typeof AccordionItemDescriptor, AccordionItemEventProps>;
+/** Пропсы секции; членство в коллекции (`selected` — раскрыта) — в `IAccordionItemProps`. */
+export type AccordionItemProps = UseDomProps<typeof AccordionItemDescriptor, IAccordionItem, AccordionItemEventProps>;

package/dist/components/accordion/item/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base.component';
+export { setupAccordionItem } from './setup.component';
+export { AccordionItem } from './Item';

package/dist/components/accordion/item/setup.component.d.ts

@@ -0,0 +1,39 @@
+import type { AccordionItemProps } from './base.component';
+export declare function setupAccordionItem(props: AccordionItemProps): {
+    context: import("@soxa-ui/core").TItemContext<import("@soxa-ui/core").IAccordionItem<import("@soxa-ui/core").IAccordionItemProps, import("@soxa-ui/core").TAccordionItemEvents>, import("@soxa-ui/core").TAccordionCollectionExtensions> | undefined;
+    ref: (el: Element) => void;
+    rootElement: import("solid-js").Accessor<Element | null>;
+    ctrl: object & import("@soxa-ui/core").IAccordionItem<import("@soxa-ui/core").IAccordionItemProps, import("@soxa-ui/core").TAccordionItemEvents>;
+    bindRef: (el: Element) => void;
+    consumerRef: (el: Element) => void;
+    state: import("../../../adapter").TJoinedState<import("@soxa-ui/setup").TAdapterState<import("@soxa-ui/setup").TContextContract<import("@soxa-ui/core").IAccordionItem<import("@soxa-ui/core").IAccordionItemProps, import("@soxa-ui/core").TAccordionItemEvents>, {
+        props: object & {} & {} & {} & {
+            aria_label?: string | undefined;
+            aria_labelledBy?: string | undefined;
+            aria_describedBy?: string | undefined;
+        } & {} & {
+            id?: string | undefined;
+        } & {};
+        events: object & {
+            "element:ready": (element: Element) => void;
+            "element:removed": () => void;
+        } & {} & {
+            "action:click": (event: MouseEvent) => void;
+            "action:press": (event: MouseEvent) => void;
+            "action:focus": (event: FocusEvent) => void;
+            "action:blur": (event: FocusEvent) => void;
+        } & {
+            "aria:change:label": (payload: import("@soxa-ui/core").TValuePayload<string | undefined>) => void;
+            "aria:change:labelledBy": (payload: import("@soxa-ui/core").TValuePayload<string | undefined>) => void;
+            "aria:change:describedBy": (payload: import("@soxa-ui/core").TValuePayload<string | undefined>) => void;
+        } & {
+            "change:id": (payload: import("@soxa-ui/core").TValuePayload<string | undefined>) => void;
+        } & {};
+        outputs: object & {} & {} & {} & {} & {} & {} & {};
+    }>>, import("@soxa-ui/setup").TAdapterState<import("@soxa-ui/setup").TContextContract<import("@soxa-ui/core").TAccordionItemCollectionFacade, {
+        props: object;
+        events: object;
+        outputs: object;
+    }>>>;
+    forwardProps: () => Partial<AccordionItemProps>;
+};

package/dist/components/accordion/item/setup.component.js

@@ -0,0 +1,24 @@
+import { createSolidAdapterContext } from "../../../adapter/common/createSolidAdapterContext.js";
+import { joinBindings, useAdapter, useCollectionAdapter } from "../../../adapter/runtime/useAdapter.js";
+import { useElevator } from "../../../adapter/elevator/useElevator.js";
+import { AccordionCollectionItemDescriptor, AccordionItemDescriptor, TCollectionItemExtension } from "@soxa-ui/setup";
+//#region src/components/accordion/item/setup.component.ts
+function setupAccordionItem(props) {
+	const { elevator } = useElevator();
+	const adapter = createSolidAdapterContext(AccordionItemDescriptor(), {
+		ctrl: props.ctrl,
+		props
+	});
+	const item = createSolidAdapterContext(AccordionCollectionItemDescriptor(), { props }, { bundle: adapter.bundle }).use(TCollectionItemExtension, {
+		adapter,
+		elevator
+	});
+	const itemBinding = useCollectionAdapter(item, props);
+	const owner = useAdapter(adapter, props);
+	return {
+		...joinBindings(owner, itemBinding),
+		context: item.instance.context
+	};
+}
+//#endregion
+export { setupAccordionItem };

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

@@ -0,0 +1,35 @@
+import type { AccordionProps } from './base.component';
+export declare function setupAccordion(props: AccordionProps): {
+    layer: import("../../adapter").TElevatorLayer;
+    ref: (el: Element) => void;
+    rootElement: import("solid-js").Accessor<Element | null>;
+    ctrl: object & import("@soxa-ui/core").IAccordion;
+    bindRef: (el: Element) => void;
+    consumerRef: (el: Element) => void;
+    state: import("../../adapter").TJoinedState<import("@soxa-ui/setup").TAdapterState<import("@soxa-ui/setup").TContextContract<import("@soxa-ui/core").IAccordion, {
+        props: object & {} & {} & {} & {
+            aria_label?: string | undefined;
+            aria_labelledBy?: string | undefined;
+            aria_describedBy?: string | undefined;
+        } & {} & {} & {} & {};
+        events: object & {
+            "element:ready": (element: Element) => void;
+            "element:removed": () => void;
+        } & {} & {
+            "action:click": (event: MouseEvent) => void;
+            "action:press": (event: MouseEvent) => void;
+            "action:focus": (event: FocusEvent) => void;
+            "action:blur": (event: FocusEvent) => void;
+        } & {
+            "aria:change:label": (payload: import("@soxa-ui/core").TValuePayload<string | undefined>) => void;
+            "aria:change:labelledBy": (payload: import("@soxa-ui/core").TValuePayload<string | undefined>) => void;
+            "aria:change:describedBy": (payload: import("@soxa-ui/core").TValuePayload<string | undefined>) => void;
+        } & {} & {} & {};
+        outputs: object & {} & {} & {} & {} & {} & {} & {} & {};
+    }>>, import("@soxa-ui/setup").TAdapterState<import("@soxa-ui/setup").TContextContract<import("@soxa-ui/core").TAccordionCollectionFacade, {
+        props: object;
+        events: object;
+        outputs: object;
+    }>>>;
+    forwardProps: () => Partial<AccordionProps>;
+};

package/dist/components/accordion/setup.component.js

@@ -0,0 +1,27 @@
+import { createSolidAdapterContext } from "../../adapter/common/createSolidAdapterContext.js";
+import { joinBindings, useAdapter, useCollectionAdapter } from "../../adapter/runtime/useAdapter.js";
+import { useElevator } from "../../adapter/elevator/useElevator.js";
+import { AccordionCollectionDescriptor, AccordionDescriptor, TCollectionExtension, TDragAndDropCollectionExtension } from "@soxa-ui/setup";
+//#region src/components/accordion/setup.component.ts
+function setupAccordion(props) {
+	const { elevator, layer } = useElevator();
+	const adapter = createSolidAdapterContext(AccordionDescriptor(), {
+		ctrl: props.ctrl,
+		props
+	});
+	const collectionAdapter = createSolidAdapterContext(AccordionCollectionDescriptor(), {
+		props,
+		options: {
+			owner: adapter.instance,
+			engine: props.engine
+		}
+	}, { bundle: adapter.bundle }).use(TCollectionExtension, { elevator }).use(TDragAndDropCollectionExtension, { elevator });
+	const collectionBinding = useCollectionAdapter(collectionAdapter, props);
+	const owner = useAdapter(adapter, props);
+	return {
+		...joinBindings(owner, collectionBinding),
+		layer
+	};
+}
+//#endregion
+export { setupAccordion };

package/dist/components/button/Button.d.ts

@@ -0,0 +1,12 @@
+import type { JSX } from 'solid-js';
+import { setupButton } from './setup.component';
+import type { ButtonProps } from './base.component';
+/** Кнопка: на месте незаданного `children` — текст из ядра. */
+export declare function Button(props: ButtonProps): JSX.Element;
+/** Что разметке кнопки нужно от её связки. */
+export type TButtonBinding = Pick<ReturnType<typeof setupButton>, 'ref' | 'forwardProps' | 'state'>;
+/**
+ * Разметка кнопки по её связке. Одна на Button и строку элемента коллекции
+ * (`ItemRow`): у них разная сборка, а разметка та же.
+ */
+export declare function renderButton(binding: TButtonBinding, props: ButtonProps): JSX.Element;