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

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

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+export type TTeleportProps = {
+    /** Селектор цели: `body`, `#layers`. */
+    to: string | undefined;
+    /** Рисовать на месте, без портала. */
+    disabled?: boolean;
+    children?: Snippet;
+};

package/dist/adapter/runtime/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,62 @@
+/**
+ * useAdapter — binds an adapter context to Svelte, the counterpart of Vue's
+ * `useAdapter`.
+ *
+ * 1. Core → Svelte: a subscription to the binding state; a property read in a
+ *    tracking context keeps its value in a raw rune
+ * 2. Svelte → Core: input props in an effect
+ * 3. The component is accepted: `adapter.attach()` at initialisation
+ * 4. Events go to the `onXxx` callback props, after the acceptance and until
+ *    `detach`
+ * 5. The root, by an attachment: to `TElementPlugin`, to the component's
+ *    `ref` and to the `rootElement` rune
+ * 6. Cleanup on destroy
+ *
+ * The collection facade is bound by `useCollectionAdapter`, before the
+ * component, and `joinBindings` joins it with the component's binding.
+ * AGENTS.md (Svelte), «Связка».
+ */
+import type { IAdapterContext, IComponentContract, TAdapterState } from '@soxa-ui/setup';
+import { type TJoinedState } from './state';
+/** The props the component did not take; it takes `ref` from `$props()` itself. */
+type TForwardProps<TProps extends object> = Omit<Partial<TProps>, 'children' | 'ctrl' | 'ref'>;
+/** The root's receiver: the component's bindable `ref` prop, `(node) => (ref = node)`. */
+export type TRootReceiver = (node: Element | null) => void;
+export type TBinding<C extends IComponentContract = IComponentContract, TProps extends object = object, TState extends object = TAdapterState<C>> = {
+    readonly ctrl: C['instance'];
+    readonly state: TState;
+    /** The consumer's root attributes, with its attachments (symbol keys). */
+    readonly forwardProps: TForwardProps<TProps>;
+    /** The root bound to `TElementPlugin`; `null` before the render. */
+    readonly rootElement: Element | null;
+    /** The root's attachment: binds to `TElementPlugin`, then the component's `ref`. */
+    attachElement: (node: Element) => () => void;
+    /** Only the binding: for a root inside a wrapper (`toWrappedRootProps`). */
+    bindRef: (node: Element) => () => void;
+    /** Only the `ref`: for the root's wrapper. */
+    consumerRef: (node: Element) => () => void;
+};
+/** The binding of a collection facade: it has no `ctrl` and no root 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: TForwardProps<TProps>) => TForwardProps<TProps>;
+};
+/** `receive` is the root's receiver; an assembly without its own root (`setupControl`) has none. */
+export declare function useAdapter<C extends IComponentContract, TProps extends object>(adapter: IAdapterContext<C>, getProps: () => TProps, receive?: TRootReceiver): TBinding<C, TProps>;
+/**
+ * The adapter of a collection facade: its state and what it leaves of the
+ * attributes. No `ctrl` and no root: they are the component's, whose binding
+ * `joinBindings` joins the facade with. Bound before the component: the
+ * facade, accepted, writes into it, and that is its starting state.
+ */
+export declare function useCollectionAdapter<F extends IComponentContract, TProps extends object>(facade: IAdapterContext<F>, getProps: () => TProps): TCollectionBinding<TAdapterState<F>, TProps>;
+/**
+ * One binding of a component and its facades, for the markup: the state of
+ * all of them as one view, the attributes of the last facade (each takes its
+ * own from the rest of the previous one, the first from the component's),
+ * `ctrl` and the root of the component.
+ */
+export declare function joinBindings<C extends IComponentContract, TProps extends object, TState extends object, TFacade extends object>(owner: TBinding<C, TProps, TState>, facade: TCollectionBinding<TFacade, TProps>): TBinding<C, TProps, TJoinedState<TFacade, TState>>;
+export declare function joinBindings<C extends IComponentContract, TProps extends object, TState extends object, TFacade extends object, TOwnerFacade extends object>(owner: TBinding<C, TProps, TState>, facade: TCollectionBinding<TFacade, TProps>, ownerFacade: TCollectionBinding<TOwnerFacade, TProps>): TBinding<C, TProps, TJoinedState<TOwnerFacade, TJoinedState<TFacade, TState>>>;
+export {};

package/dist/adapter/runtime/useAdapter.svelte.js

@@ -0,0 +1,228 @@
+/**
+ * useAdapter — binds an adapter context to Svelte, the counterpart of Vue's
+ * `useAdapter`.
+ *
+ * 1. Core → Svelte: a subscription to the binding state; a property read in a
+ *    tracking context keeps its value in a raw rune
+ * 2. Svelte → Core: input props in an effect
+ * 3. The component is accepted: `adapter.attach()` at initialisation
+ * 4. Events go to the `onXxx` callback props, after the acceptance and until
+ *    `detach`
+ * 5. The root, by an attachment: to `TElementPlugin`, to the component's
+ *    `ref` and to the `rootElement` rune
+ * 6. Cleanup on destroy
+ *
+ * The collection facade is bound by `useCollectionAdapter`, before the
+ * component, and `joinBindings` joins it with the component's binding.
+ * AGENTS.md (Svelte), «Связка».
+ */
+import { onDestroy, untrack } from 'svelte';
+import { toInstanceState } from '@soxa-ui/setup';
+import { SvelteProfile } from '../common';
+import { joinState } from './state';
+/** An assembly without its own root (`setupControl`): there is no one to give the node to. */
+const NO_RECEIVER = () => { };
+/**
+ * The own rune of a binding property a tracking context has read: a raw rune
+ * (`$state.raw`). The core hands out values, not handles on live state, and
+ * reports a change with a new value (AGENTS.md, «Контракт границы core →
+ * ui»). The deep `$state` rune wrapped everything composite in a proxy (the
+ * array of a table row's cells, each cell, its `aria` and `dataset`) with a
+ * source per key read, and there is nothing to watch: nobody changes them in
+ * place. In the table that was a third of a row's memory
+ * (benchmarks/table/svelte.md, 869fmcau7).
+ *
+ * `born` is the binding's version when the rune was made (see `TValues`).
+ */
+class TRawValue {
+    born;
+    value = $state.raw();
+    constructor(value, born) {
+        this.born = born;
+        this.value = value;
+    }
+}
+/** `TValues` with the version in a raw rune. */
+class TValueStore {
+    values = new Map();
+    version = $state.raw(0);
+}
+/** Whether the property has arrived; as an object property, a symbol never has. */
+function has({ values }, name) {
+    return typeof name === 'string' && values.has(name);
+}
+/** Value of the property; read in a tracking context, a property without a rune gets one. */
+function valueOf(target, name) {
+    if (!has(target, name))
+        return undefined;
+    const entry = target.values.get(name);
+    if (entry instanceof TRawValue)
+        return entry.value;
+    if ($effect.tracking())
+        target.values.set(name, new TRawValue(entry, target.version));
+    return entry;
+}
+/** New value from the subscription; the caller writes it untracked (see `useExchange`). */
+function write(target, name, value) {
+    const entry = target.values.get(name);
+    if (!(entry instanceof TRawValue)) {
+        target.values.set(name, value);
+    }
+    else if (entry.value !== value) {
+        if (entry.born === target.version)
+            target.version++;
+        entry.value = value;
+    }
+}
+/**
+ * Binding state: a proxy over its properties, one handler for all bindings.
+ * A getter per property (a closure, its scopes and a pair of accessors) cost
+ * a table row kilobytes (benchmarks/table/svelte.md).
+ */
+const STATE = {
+    get: valueOf,
+    has,
+    ownKeys: ({ values }) => [...values.keys()],
+    getOwnPropertyDescriptor: (target, name) => has(target, name)
+        ? {
+            value: valueOf(target, name),
+            enumerable: true,
+            configurable: true,
+            writable: false,
+        }
+        : undefined,
+};
+/** What `useAdapter` and `useCollectionAdapter` share. */
+function useExchange(adapter, getProps) {
+    const exchange = adapter.connect(SvelteProfile);
+    const values = new TValueStore();
+    // 1. Subscribe right away, not in an effect: there are no effects on the
+    // server. The write is untracked: the core changes in the middle of
+    // rendering too
+    onDestroy(exchange.state.subscribe((name, value) => {
+        untrack(() => write(values, name, value));
+    }));
+    // 2. The effect reads all props, the binding writes only the changed ones
+    $effect(() => {
+        exchange.inputs.full(getProps());
+    });
+    // 3. The component's initialisation, on the server too, is its mount: a
+    // collection item joins the collection by the server markup, in DOM order
+    adapter.attach();
+    // 4. Events after the acceptance: what it writes is the starting state, as
+    // in the other adapters (benchmarks/parity/README.md). A component with
+    // collection facades binds them first: the facade, accepted, writes into
+    // the component (the months of Calendar's grids, Table's `dataset`). One
+    // subscription for the whole life, at initialisation, like the state: in an
+    // effect it began after the children, and the markup items that joined the
+    // collection while mounting never reached the consumer. The callback is
+    // read lazily and called untracked: an event comes in the middle of
+    // rendering too (an item joins inside the owner's block), and a consumer
+    // writing its state there would be an unsafe mutation for Svelte.
+    // `onDestroy` unsubscribes on the server, where effects do not run
+    const stop = exchange.events.listen((exportName, args) => {
+        untrack(() => {
+            const callback = Reflect.get(getProps(), exportName);
+            if (typeof callback === 'function')
+                callback(...args);
+        });
+    });
+    onDestroy(stop);
+    // The consumer stops on `detach`: it hears nothing once the teardown began,
+    // as in the other adapters (benchmarks/parity/README.md). `detach` comes
+    // from a pre-effect's teardown: Svelte destroys a block's effects in the
+    // order they were made, and a pre-effect is made at once, before the
+    // template's blocks, while `$effect` and `onDestroy` wait for the mount and
+    // come after them. Stopped in those, the consumer heard the children go (the
+    // markup items leaving the collection with an ever shorter list, the root's
+    // unbinding). A collection item is also detached by its collection, before
+    // the siblings go one by one (`TCollectionMembers`). The nodes are removed
+    // before any effect, so the blur of a removed node still reaches the
+    // consumer
+    adapter.events.on('detach', stop);
+    $effect.pre(() => () => adapter.detach());
+    // 6. One effect that tracks nothing: its teardown destroys the adapter
+    $effect(() => () => adapter.destroy());
+    return { exchange, state: new Proxy(values, STATE) };
+}
+/**
+ * What the binding did not take, plus the consumer's attachments: Svelte
+ * passes them as props with symbol keys, and the binding does not see them.
+ */
+function forwardOf(exchange, props) {
+    const forward = exchange.forward(props);
+    for (const key of Object.getOwnPropertySymbols(props)) {
+        Reflect.set(forward, key, Reflect.get(props, key));
+    }
+    return forward;
+}
+/** `receive` is the root's receiver; an assembly without its own root (`setupControl`) has none. */
+export function useAdapter(adapter, getProps, receive = NO_RECEIVER) {
+    const { exchange, state } = useExchange(adapter, getProps);
+    const forwardProps = $derived(forwardOf(exchange, getProps()));
+    let rootElement = $state.raw(null);
+    // 5. A tag change recreates the node: the cleanup unbinds the previous one
+    const bindRef = (node) => {
+        adapter.bindElement(node);
+        rootElement = node;
+        return () => {
+            adapter.bindElement(null);
+            rootElement = null;
+        };
+    };
+    // Untracked: the `bind:ref={get, set}` setter is consumer code, and what it
+    // reads would rerun the attachment
+    const consumerRef = (node) => {
+        untrack(() => receive(node));
+        return () => untrack(() => receive(null));
+    };
+    return {
+        ctrl: adapter.instance,
+        state: toInstanceState(state),
+        bindRef,
+        consumerRef,
+        get forwardProps() {
+            return forwardProps;
+        },
+        get rootElement() {
+            return rootElement;
+        },
+        attachElement(node) {
+            const unbind = bindRef(node);
+            const release = consumerRef(node);
+            return () => {
+                unbind();
+                release();
+            };
+        },
+    };
+}
+/**
+ * The adapter of a collection facade: its state and what it leaves of the
+ * attributes. No `ctrl` and no root: they are the component's, whose binding
+ * `joinBindings` joins the facade with. Bound before the component: the
+ * facade, accepted, writes into it, and that is its starting state.
+ */
+export function useCollectionAdapter(facade, getProps) {
+    const { exchange, state } = useExchange(facade, getProps);
+    return {
+        state: toInstanceState(state),
+        forward: (props) => forwardOf(exchange, props),
+    };
+}
+export function joinBindings(owner, ...facades) {
+    const forwardProps = $derived(facades.reduce((rest, facade) => facade.forward(rest), owner.forwardProps));
+    return {
+        ctrl: owner.ctrl,
+        state: facades.reduce((state, facade) => joinState(facade.state, state), owner.state),
+        attachElement: owner.attachElement,
+        bindRef: owner.bindRef,
+        consumerRef: owner.consumerRef,
+        get forwardProps() {
+            return forwardProps;
+        },
+        get rootElement() {
+            return owner.rootElement;
+        },
+    };
+}

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/index.js

@@ -0,0 +1,2 @@
+export { useToasts } from './useToasts';
+export { isToastRender } from './render';

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

@@ -0,0 +1,3 @@
+import type { TToastRender } from './types';
+/** Своё содержимое тоста — компонент Svelte, то есть функция. */
+export declare function isToastRender(value: unknown): value is TToastRender;

package/dist/adapter/toasts/render.js

@@ -0,0 +1,4 @@
+/** Своё содержимое тоста — компонент Svelte, то есть функция. */
+export function isToastRender(value) {
+    return typeof value === 'function';
+}

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

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

package/dist/adapter/toasts/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+import type { IToastsApi } from '@soxa-ui/core';
+import type { TToastRender } from './types';
+/**
+ * API тостов ближайшего `<Toasts>` — лифтом, поэтому только при
+ * инициализации компонента. Нет менеджера — ошибка, а не молчаливый `show`.
+ */
+export declare function useToasts(): IToastsApi<TToastRender>;

package/dist/adapter/toasts/useToasts.js

@@ -0,0 +1,13 @@
+import { TOASTS_ELEVATOR } from '@soxa-ui/setup';
+import { useElevator } from '../elevator';
+/**
+ * API тостов ближайшего `<Toasts>` — лифтом, поэтому только при
+ * инициализации компонента. Нет менеджера — ошибка, а не молчаливый `show`.
+ */
+export function useToasts() {
+    const api = useElevator()(TOASTS_ELEVATOR).up();
+    if (!api) {
+        throw new Error('useToasts(): выше по дереву нет <Toasts>. Оберните приложение менеджером: <Toasts><App /></Toasts>');
+    }
+    return api;
+}

package/dist/components/accordion/Accordion.svelte

@@ -0,0 +1,43 @@
+<script lang="ts">
+	import { Dynamic, toRootProps } from '../../adapter'
+	import { AccordionItem } from './item'
+	import { setupAccordion } from './setup.component'
+	import type { AccordionProps } from './base.component'
+
+	let { ref = $bindable(), ...props }: AccordionProps = $props()
+	const mountId = $props.id()
+
+	const binding = setupAccordion(() => props, mountId, (node) => (ref = node))
+	const state = binding.state
+</script>
+
+<Dynamic
+	rendered={state.rendered}
+	tag="div"
+	attributes={toRootProps(state, [state.attrs], binding.forwardProps)}
+	attach={binding.attachElement}
+>
+	{#if props.children}
+		{@render props.children()}
+	{:else}
+		{#each state.shown ?? [] as section (section.uid)}
+			{#snippet arrowIcon()}
+				{@render props['item-arrow-icon']?.({ item: section })}
+			{/snippet}
+			{#snippet leading()}{@render props['item-leading']?.({ item: section })}{/snippet}
+			{#snippet header(scope: { text: string; selected: boolean })}
+				{@render props.item?.({ ...scope, item: section })}
+			{/snippet}
+			{#snippet trailing()}{@render props['item-trailing']?.({ item: section })}{/snippet}
+			{#snippet content()}{@render props['item-content']?.({ item: section })}{/snippet}
+			<AccordionItem
+				ctrl={section}
+				arrow-icon={props['item-arrow-icon'] ? arrowIcon : undefined}
+				leading={props['item-leading'] ? leading : undefined}
+				header={props.item ? header : undefined}
+				trailing={props['item-trailing'] ? trailing : undefined}
+				children={props['item-content'] ? content : undefined}
+			/>
+		{/each}
+	{/if}
+</Dynamic>

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

@@ -0,0 +1,4 @@
+import type { AccordionProps } from './base.component';
+declare const Accordion: import("svelte").Component<AccordionProps, {}, "ref">;
+type Accordion = ReturnType<typeof Accordion>;
+export default Accordion;

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

@@ -0,0 +1,5 @@
+import type { IAccordion } from '@soxa-ui/core';
+import type { AccordionCollectionDescriptor, AccordionDescriptor } from '@soxa-ui/setup';
+import type { EventProps, UseDomProps } from '../../types';
+export type AccordionEventProps = EventProps<typeof AccordionDescriptor> & EventProps<typeof AccordionCollectionDescriptor>;
+export type AccordionProps = UseDomProps<typeof AccordionDescriptor, IAccordion, AccordionEventProps>;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+export * from './base.component';
+export { setupAccordion } from './setup.component';
+export * from './item';
+export declare const Accordion: import("svelte").Component<import("./base.component").AccordionProps, {}, "ref"> & {
+    Item: import("svelte").Component<import("./item").AccordionItemProps, {}, "ref">;
+};

package/dist/components/accordion/index.js

@@ -0,0 +1,7 @@
+import { withParts } from '@soxa-ui/setup';
+import AccordionComponent from './Accordion.svelte';
+import { AccordionItem } from './item';
+export * from './base.component';
+export { setupAccordion } from './setup.component';
+export * from './item';
+export const Accordion = withParts(AccordionComponent, { Item: AccordionItem });

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

@@ -0,0 +1,84 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte'
+	import { clickAction, Dynamic, roleIcon, toControlAttrs, toRootForward, toRootProps } from '../../../adapter'
+	import { Button } from '../../button'
+	import { Icon } from '../../icon'
+	import { setupAccordionItem } from './setup.component'
+	import type { AccordionItemAttributes, AccordionItemProps } from './base.component'
+
+	let { ref = $bindable(), ...props }: AccordionItemProps = $props()
+	const mountId = $props.id()
+
+	const binding = setupAccordionItem(() => props, mountId, (node) => (ref = node))
+	const state = binding.state
+	const context = binding.context
+	const toggle = clickAction(() => context?.adapters.selection.toggle())
+
+	const ARROW = roleIcon('arrowRight')
+</script>
+
+<!--
+	Класс стрелки — на обёртке, а не на иконке: тема поворачивает стрелку раскрытой секции по
+	`.so-accordion-item__arrow`, и подменённая слотом иконка поворачивается так же. Обёртка
+	стоит, пока на её стороне стрелка по умолчанию или задан слот.
+-->
+{#snippet arrow(side: 'start' | 'end', slot: Snippet<[{ item: typeof binding.ctrl }]> | undefined)}
+	{#if state.arrowPlacement === side}
+		<span class="so-accordion-item__arrow">
+			{#if slot}
+				{@render slot({ item: binding.ctrl })}
+			{:else}
+				<Icon embedded="accordion.arrow" tag={ARROW} size={state.size} />
+			{/if}
+		</span>
+	{/if}
+{/snippet}
+
+<Dynamic
+	rendered={state.rendered}
+	tag={state.tag}
+	attributes={toRootProps(
+		state,
+		[state.dataset, state.attrs],
+		toRootForward(binding.forwardProps),
+	)}
+	attach={binding.attachElement}
+>
+	<Button
+		embedded="accordion.header"
+		type="button"
+		class="so-accordion-item__header"
+		view={state.view}
+		disabled={state.disabled}
+		size={state.size}
+		variant={state.variant}
+		{...state.aria}
+		{...toControlAttrs<AccordionItemAttributes>(binding.forwardProps)}
+		{@attach toggle}
+	>
+		{#snippet leading()}
+			{@render arrow('start', props['arrow-icon'])}{@render props.leading?.({
+				item: binding.ctrl,
+			})}
+		{/snippet}
+		{#if props.header}
+			{@render props.header({
+				item: binding.ctrl,
+				text: state.text ?? '',
+				selected: state.selected ?? false,
+			})}
+		{:else}
+			{state.text}
+		{/if}
+		{#snippet trailing()}
+			{@render props.trailing?.({ item: binding.ctrl })}{@render arrow(
+				'end',
+				props['arrow-icon'],
+			)}
+		{/snippet}
+	</Button><div class="so-accordion-item__body">
+		<div class="so-accordion-item__content" {...state.contentAria}>
+			{@render props.children?.({ item: binding.ctrl })}
+		</div>
+	</div>
+</Dynamic>

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

@@ -0,0 +1,4 @@
+import type { AccordionItemProps } from './base.component';
+declare const Item: import("svelte").Component<AccordionItemProps, {}, "ref">;
+type Item = ReturnType<typeof Item>;
+export default Item;

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

@@ -0,0 +1,7 @@
+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>;
+export type AccordionItemProps = UseDomProps<typeof AccordionItemDescriptor, IAccordionItem, AccordionItemEventProps>;

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

@@ -0,0 +1 @@
+export {};

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

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

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

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

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

@@ -0,0 +1,57 @@
+import { type TRootReceiver } from '../../../adapter';
+import type { AccordionItemProps } from './base.component';
+export declare function setupAccordionItem(getProps: () => AccordionItemProps, mountId: string, receive: TRootReceiver): import("../../../adapter").TBinding<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 & {} & {} & {} & {} & {} & {} & {};
+}>, AccordionItemProps, import("../../../adapter/runtime/state").TJoinedState<import("@soxa-ui/setup").TAdapterState<import("@soxa-ui/setup").TContextContract<import("@soxa-ui/core").TAccordionItemCollectionFacade, {
+    props: object;
+    events: object;
+    outputs: object;
+}>>, 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 & {} & {} & {} & {} & {} & {} & {};
+}>>>> & {
+    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;
+};

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

@@ -0,0 +1,15 @@
+import { AccordionCollectionItemDescriptor, AccordionItemDescriptor, TCollectionItemExtension, } from '@soxa-ui/setup';
+import { createSvelteAdapterContext, joinBindings, useAdapter, useCollectionAdapter, useElevator, } from '../../../adapter';
+export function setupAccordionItem(getProps, mountId, receive) {
+    const elevator = useElevator();
+    const props = getProps();
+    const adapter = createSvelteAdapterContext(AccordionItemDescriptor(), {
+        ctrl: props.ctrl,
+        props,
+        mountId,
+    });
+    const item = createSvelteAdapterContext(AccordionCollectionItemDescriptor(), { props, mountId }, { bundle: adapter.bundle }).use(TCollectionItemExtension, { adapter, elevator });
+    const itemBinding = useCollectionAdapter(item, getProps);
+    const owner = useAdapter(adapter, getProps, receive);
+    return Object.assign(joinBindings(owner, itemBinding), { context: item.instance.context });
+}