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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuri Soldatov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,267 @@
-# Temporary Holding Version
+# @soxa-ui/solid
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**The Solid adapter: Soxa UI components rendered on the headless models of the core.**
+
+Part of [Soxa UI](https://github.com/youra-h/soxa-ui) — UI components with the logic written once: a
+framework-agnostic core and thin adapters that render it in Vue, React, Angular, Svelte, Solid and
+Web Components.
+
+The adapter is wiring, not behavior: it connects a core model to Solid's signals and renders the
+markup — BEM classes `so-*` and `data-*` state attributes. Props, events and slots come from the
+component descriptor, so they match the other five adapters; only the spelling is Solid's: events
+arrive as callback props (`element:ready` → `onElementReady`), and the default slot is `children`.
+
+> **Status:** the Solid adapter is in progress — Button, Icon, Label, Frame, Popover (a non-modal
+> panel with any content at its trigger), Tooltip (a hint shown on hover and on keyboard focus),
+> Dialog (a modal window), Drawer (a panel that slides in at an edge and can be swiped away),
+> Toasts (notifications shown from code with `useToasts()`),
+> Menu (an action menu at a button or a context menu on right click — `openOn="contextmenu"` —
+> with `<Menu.Item>`, `<Menu.CheckboxItem>`, `<Menu.RadioGroup>` with `<Menu.RadioItem>`,
+> `<Menu.Submenu>`, `<Menu.PopoverItem>`, `<Menu.Group>` and `<Menu.Separator>` or `items`, where
+> an item with nested `items` is a submenu), ProgressSpinner, ProgressLinear, Skeleton, the fields
+> Input, NumberInput (a number in the locale's format with − and + step buttons; the form gets the
+> number), Textarea (multi-line, growing with its text, with a character counter), CheckBox and
+> Switch, Slider (a number or a range) and Rating, the form field `Field` (label, helper and error
+> linked to the control inside it), the dates — DateInput (a date, or a date and time with
+> `kind="datetime"`, typed in parts in the locale's format; the form gets the date as a string),
+> Calendar (month grids of `Calendar.Item` days; a month heading opens the month and year picker)
+> and DatePicker (a date field and a calendar in a panel: a single date or a range, with Cancel
+> and OK buttons under `confirmable`), the collections ListBox, Tabs, Accordion, RadioGroup and Tags
+> (`<ListBox.Item>`, `<Tabs.Item>` with `<Tabs.Content>`, `<Accordion.Item>`, `<RadioGroup.Item>`,
+> `<Tags.Item>` or `items`; tags close, select by mode and either wrap or scroll), Select (a
+> combobox: `<Select.Item>` and `<Select.Group>` or `items`, `editable` with search or filter,
+> tags in the field in `multiple`), Pagination, Table (columns and rows as data — `columns`,
+> `items` — with sorting, row selection, column resizing and reordering), the `Scroller` strip,
+> the `Virtual` window for long lists (`<Virtual><ListBox items={…} /></Virtual>`, the same with
+> `Select` and `Table`) and the
+> `DragAndDrop` wrapper that lets users reorder the items of Tabs, ListBox and Accordion by
+> dragging (`<DragAndDrop onMove={…}><ListBox items={…} /></DragAndDrop>`, `onMoveBefore` can
+> cancel) are ported, the rest of the set is on its way. Icon renders the `tag` it is given: an
+> element name, a Solid component, or `roleIcon(role)` — the icon of that role from the registered
+> icon pack.
+> Frame teleports its panel into `target` (`body` by default) on the client; with `contained` it
+> stays in place. Dialog and Drawer are teleported the same way, with their backdrop next to the
+> panel, and so is the region of Toasts; `ref` of Dialog and Drawer is the panel, of Toasts — the
+> region. A change of `contained` or `target` moves the same nodes, and a field in the panel keeps
+> what was typed. Popover, Tooltip and Menu keep the trigger in their root and anchor their panel,
+> a Frame, to that root; your attributes and `ref` go to the root, not to the panel. The items of a
+> menu stand in its panel, so they are drawn on the client, not on the server. Select anchors its
+> list panel to its root the same way: the server renders a Select from `items` with the text of
+> the selected option (with tags in `multiple`); options given as markup live in the panel and
+> join the collection on the client. A field — and Select — gives its class and style to the root
+> and every other attribute to its `<input>` (a textarea — to its `<textarea>`), except Slider and
+> Rating: they keep every attribute on the root — a slider has a field per thumb, and the pointer
+> never reaches the field. DateInput, Calendar and DatePicker keep every attribute on the root too:
+> a date field has no `<input>` to type in, only its parts. The panel of DatePicker is teleported
+> like the panel of Select, so the server renders the field and the calendar button, and the
+> calendar appears on the client. An item of a collection, a menu item too, gives them to its row; a list
+> box and tabs give them to the list itself, `[role=listbox]` or `[role=tablist]`; a table gives
+> them to the `<table>` itself, and its class, style and `ref` to the scroll viewport around it;
+> otherwise `ref` gets the root. `Label` names the control it wraps; `LocaleProvider` gives a
+> subtree its language and library strings, such as the name of the clear button of `Input` or the
+> arrows of `Pagination`. See
+> [the adapter table](https://github.com/youra-h/soxa-ui#components).
+
+## Install
+
+```bash
+npm install @soxa-ui/solid @soxa-ui/setup @soxa-ui/theme-oren @soxa-ui/icons-material
+```
+
+Install `@soxa-ui/setup` as a direct dependency for the `useIcons` and `useTheme` imports below.
+Keep it on the same version as `@soxa-ui/solid`.
+
+Solid `^1.9.13` is a peer dependency. The package ships its components as source with JSX under the
+`solid` export condition, so your app's bundler compiles them with its Solid plugin (for Vite,
+`vite-plugin-solid`). A theme and an icon pack are separate packages — pick the ones you want.
+
+## Usage
+
+```tsx
+import { Button } from '@soxa-ui/solid'
+
+export function Toolbar() {
+  return <Button text="Save" onActionPress={() => console.log('pressed')} />
+}
+```
+
+The same component can be driven from code — pass a core instance as `ctrl`, and both sides see the
+same state and events:
+
+```tsx
+import { TButton } from '@soxa-ui/core'
+import { Button } from '@soxa-ui/solid'
+
+const btn = new TButton({ text: 'Save' })
+
+export function Toolbar() {
+  return <Button ctrl={btn} onActionPress={() => (btn.disabled = true)} />
+}
+```
+
+An icon from the registered pack — the root of `Icon` is an `<svg>` of that role:
+
+```tsx
+import { Icon, roleIcon } from '@soxa-ui/solid'
+
+export function CloseIcon() {
+  return <Icon tag={roleIcon('close')} aria_label="Close" />
+}
+```
+
+A collection takes its items as markup parts or as data (`items`). Tabs keep their panels in the
+`content` slot, next to the list of tabs rather than inside it:
+
+```tsx
+import { Tabs } from '@soxa-ui/solid'
+
+export function Settings() {
+  return (
+    <Tabs
+      aria_label="Settings"
+      content={
+        <>
+          <Tabs.Content value="general">General settings</Tabs.Content>
+          <Tabs.Content value="privacy">Privacy settings</Tabs.Content>
+        </>
+      }
+    >
+      <Tabs.Item value="general" text="General" active />
+      <Tabs.Item value="privacy" text="Privacy" />
+    </Tabs>
+  )
+}
+```
+
+Items given as data are drawn by the owner, and their slots are the owner's `item-<slot>` props,
+with the item in the scope: `item={(scope) => <b>{scope.item.text}</b>}`. Read the scope in the
+markup, as you read Solid props, rather than destructuring it: the markup follows the scope in
+place, while a destructured scope redraws the whole slot on every change — on every selection — and
+a button or field in the slot loses its focus. An item whose slot drew nothing draws its own content
+instead — its text, check mark or close icon.
+
+A popover opens a panel with any content at its trigger. The trigger is your own element in the
+`trigger` slot; the link to the panel comes in the slot scope — `triggerAria` (`aria-haspopup`,
+`aria-expanded`, `aria-controls`) and `triggerDataset` (`data-selected` of an open trigger):
+
+```tsx
+import { Button, Popover } from '@soxa-ui/solid'
+
+export function Filters() {
+  return (
+    <Popover
+      aria_label="Filters"
+      trigger={(scope) => (
+        <Button text="Filters" {...scope.triggerAria} {...scope.triggerDataset} />
+      )}
+    >
+      Any content: text, fields, buttons
+    </Popover>
+  )
+}
+```
+
+Here too the scope is read in the markup: the link changes on every opening, and a spread of
+`scope.triggerAria` updates the same trigger in place, while a destructured scope would draw a new
+trigger each time, and the focus on the old one would be lost. `Tooltip` takes its trigger the same
+way, with `triggerAria` in the scope.
+
+A menu takes its trigger the same way. Choosing an action closes the menu and calls `onChoose`; a
+checkbox item and a radio item are checked in place, and the menu stays open:
+
+```tsx
+import { Button, Menu } from '@soxa-ui/solid'
+
+export function Actions() {
+  return (
+    <Menu
+      trigger={(scope) => (
+        <Button text="Actions" {...scope.triggerAria} {...scope.triggerDataset} />
+      )}
+      onChoose={(item) => console.log(item.value)}
+    >
+      <Menu.Item value="edit" text="Edit" />
+      <Menu.Submenu value="share" text="Share">
+        <Menu.Item value="link" text="Copy link" />
+        <Menu.Item value="mail" text="Email" />
+      </Menu.Submenu>
+      <Menu.Separator />
+      <Menu.Item value="remove" text="Delete" />
+    </Menu>
+  )
+}
+```
+
+Toasts are shown from code. The manager wraps the application, and any component under it takes
+the API in its body, like `useContext` — a component in a dialog under the manager too; your own
+content of a toast is a Solid component with a `toast` prop:
+
+```tsx
+import { Button, Toasts, useToasts, type TToastRender } from '@soxa-ui/solid'
+
+const Undo: TToastRender = (props) => <Button text="Undo" onClick={() => props.toast.close()} />
+
+function Page() {
+  const { show } = useToasts()
+
+  return <Button text="Delete" onClick={() => show({ text: 'Deleted', render: Undo })} />
+}
+
+export function App() {
+  return (
+    <Toasts>
+      <Page />
+    </Toasts>
+  )
+}
+```
+
+The application plugs in a theme and an icon pack once, in its entry point:
+
+```ts
+import { useIcons, useTheme } from '@soxa-ui/setup'
+import * as material from '@soxa-ui/icons-material'
+import oren from '@soxa-ui/theme-oren/setup'
+
+import '@soxa-ui/theme-oren'
+
+useIcons(material)
+useTheme(oren)
+```
+
+`@soxa-ui/theme-oren` is the stylesheet of every component. To take only the components your
+pages use, import their stylesheets instead — `@soxa-ui/theme-oren/button.css`,
+`@soxa-ui/theme-oren/select.css`, one per component, each with the shared part of the theme
+(the theme's README, [Only the components you use](https://github.com/youra-h/soxa-ui/tree/main/packages/themes/oren#only-the-components-you-use)).
+
+## Server rendering
+
+Server rendering and hydration — SolidStart, or Vite SSR with `vite-plugin-solid({ ssr: true })` —
+need nothing extra: the Solid plugin finds the package by its `solid` export condition and compiles
+its components together with your app, for the server and for the browser. A bundler without the
+Solid plugin gets the `default` export instead — a build for the browser, which does not render on
+the server.
+
+## Documentation
+
+- [Soxa UI README](https://github.com/youra-h/soxa-ui#readme) — the component set and what each
+  adapter implements so far.
+- [Architecture overview](https://github.com/youra-h/soxa-ui/blob/main/docs/architecture.md) —
+  layers, descriptors, plugins, collections, adapters.
+
+## Public API
+
+The package entry exports application components, their consumer types, the locale provider,
+and the supported icon and toast helpers. Component props, slots, events, refs and core models
+passed through `ctrl` remain the supported ways to customize the UI. Models come from
+`@soxa-ui/core`; theme, icon and external-plugin registration comes from `@soxa-ui/setup`.
+
+Assembly functions, adapter profiles, bindings, generated metadata and rendering templates
+are private implementation details. They are no longer exported from the package entry, and
+there is no public `/internal` entry. Code that imported them must use the component contract
+instead. Building a new adapter component from Soxa's assembly helpers is not a supported
+public SDK.
+
+## License
+
+[MIT](https://github.com/youra-h/soxa-ui/blob/main/LICENSE)

package/dist/adapter/common/ResolvedSlot.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Слот, развёрнутый там, где стоит в разметке: под `Elevate` владельца
+ * коллекции, чтобы элементы в слоте видели его слой. Задан ли слот, решает
+ * его значение, а не узлы: компонент в слоте — содержимое, что бы он ни
+ * нарисовал. AGENTS.md (Solid), «Слоты».
+ *
+ * - незаданный — `fallback` (у владельца коллекции — элементы из данных);
+ * - заданный — узлы, а с `children` — обёртка вокруг них;
+ * - со `scope` — функция слота получает его живым и зовётся один раз.
+ */
+import { type Accessor, type JSX } from 'solid-js';
+import { type TSlotContent } from './slots';
+type TResolvedSlotBase = {
+    fallback?: JSX.Element;
+    /** Обёртка вокруг заданного слота. */
+    children?: (nodes: Accessor<JSX.Element | undefined>) => JSX.Element;
+};
+/** Без scope функция слота не проходит: звать её было бы не с чем. */
+type TPlainSlotProps = TResolvedSlotBase & {
+    content: JSX.Element | undefined;
+    scope?: undefined;
+};
+type TScopedSlotProps<TScope extends object> = TResolvedSlotBase & {
+    content: TSlotContent<TScope> | undefined;
+    scope: () => TScope;
+};
+export type TResolvedSlotProps<TScope extends object = object> = TPlainSlotProps | TScopedSlotProps<TScope>;
+export declare function ResolvedSlot<TScope extends object>(props: TResolvedSlotProps<TScope>): JSX.Element;
+export {};

package/dist/adapter/common/ResolvedSlot.js

@@ -0,0 +1,42 @@
+import { hasSlot, slotValue } from "./slots.js";
+import { Show as Show$1 } from "../runtime/flow.js";
+import { children, createMemo } from "solid-js";
+import { createComponent } from "solid-js/web";
+//#region src/adapter/common/ResolvedSlot.tsx
+/**
+* Слот, развёрнутый там, где стоит в разметке: под `Elevate` владельца
+* коллекции, чтобы элементы в слоте видели его слой. Задан ли слот, решает
+* его значение, а не узлы: компонент в слоте — содержимое, что бы он ни
+* нарисовал. AGENTS.md (Solid), «Слоты».
+*
+* - незаданный — `fallback` (у владельца коллекции — элементы из данных);
+* - заданный — узлы, а с `children` — обёртка вокруг них;
+* - со `scope` — функция слота получает его живым и зовётся один раз.
+*/
+function ResolvedSlot(props) {
+	const value = valueOf(props);
+	const nodes = children(value);
+	const wrap = props.children;
+	return createComponent(Show$1, {
+		get when() {
+			return hasSlot(value());
+		},
+		get fallback() {
+			return props.fallback;
+		},
+		get children() {
+			return wrap ? wrap(nodes) : nodes();
+		}
+	});
+}
+/** Значение слота мемо; есть ли у слота scope, за жизнь компонента не меняется. */
+function valueOf(props) {
+	if (props.scope === void 0) return createMemo(() => slotValue(() => props.content, noScope));
+	const scope = props.scope;
+	return createMemo(() => slotValue(() => props.content, scope));
+}
+function noScope() {
+	return {};
+}
+//#endregion
+export { ResolvedSlot };

package/dist/adapter/common/click-action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The action of a part on a click (activate a tab, choose an option, close a
+ * panel) — a native listener on the part's node, given as its `ref`.
+ * AGENTS.md (Solid), «Клик части».
+ */
+export declare function clickAction(action: (event: Event) => void): (node: Element) => void;

package/dist/adapter/common/click-action.js

@@ -0,0 +1,11 @@
+//#region src/adapter/common/click-action.ts
+/**
+* The action of a part on a click (activate a tab, choose an option, close a
+* panel) — a native listener on the part's node, given as its `ref`.
+* AGENTS.md (Solid), «Клик части».
+*/
+function clickAction(action) {
+	return (node) => node.addEventListener("click", action);
+}
+//#endregion
+export { clickAction };

package/dist/adapter/common/createSolidAdapterContext.d.ts

@@ -0,0 +1,8 @@
+import { createAdapterContext } from '@soxa-ui/setup';
+/**
+ * Сборка компонента Solid поверх `createAdapterContext`: id монтирования —
+ * `createUniqueId()` (совпадает на сервере и при гидратации), локаль —
+ * ближайшего `LocaleProvider`. Контекст на чужом наборе (фасад коллекции) их
+ * не берёт: они у того, кто набор собрал. Зовётся в теле компонента.
+ */
+export declare const createSolidAdapterContext: typeof createAdapterContext;

package/dist/adapter/common/createSolidAdapterContext.js

@@ -0,0 +1,20 @@
+import { nearestLocale } from "../locale/context.js";
+import { createAdapterContext } from "@soxa-ui/setup";
+import { createUniqueId } from "solid-js";
+//#region src/adapter/common/createSolidAdapterContext.ts
+/**
+* Сборка компонента Solid поверх `createAdapterContext`: id монтирования —
+* `createUniqueId()` (совпадает на сервере и при гидратации), локаль —
+* ближайшего `LocaleProvider`. Контекст на чужом наборе (фасад коллекции) их
+* не берёт: они у того, кто набор собрал. Зовётся в теле компонента.
+*/
+var createSolidAdapterContext = (descriptor, options, config) => {
+	if (config?.bundle !== void 0) return createAdapterContext(descriptor, options, config);
+	return createAdapterContext(descriptor, {
+		...options,
+		mountId: options.mountId ?? createUniqueId(),
+		locale: options.locale ?? nearestLocale()
+	}, config);
+};
+//#endregion
+export { createSolidAdapterContext };

package/dist/adapter/common/handlers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Своё, затем обработчик потребителя — на одном событии разметки: в Solid
+ * событие — проп, и обработчик потребителя занял бы место своего.
+ */
+/** Обработчик в любой форме разметки Solid: функция или пара `[handler, data]`. */
+export type THandlerUnion<TEvent> = ((event: TEvent) => void) | {
+    readonly 0: (data: unknown, event: TEvent) => void;
+    readonly 1: unknown;
+};
+export declare function chainHandler<TEvent>(own: (event: TEvent) => void, consumer: THandlerUnion<TEvent> | undefined): (event: TEvent) => void;

package/dist/adapter/common/handlers.js

@@ -0,0 +1,10 @@
+//#region src/adapter/common/handlers.ts
+function chainHandler(own, consumer) {
+	return (event) => {
+		own(event);
+		if (typeof consumer === "function") consumer(event);
+		else consumer?.[0](consumer[1], event);
+	};
+}
+//#endregion
+export { chainHandler };

package/dist/adapter/common/hydration.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Окна гидратации и мемо, которое их переживает: раскладка корня и частей
+ * (`root.ts`), ветки и петли (`../runtime/flow.ts`, `KeyedFor`).
+ * AGENTS.md (Solid), «Окна гидратации».
+ */
+import { type Accessor } from 'solid-js';
+/**
+ * Открыто ли окно гидратации — условие `isHydrating` из `solid-js/web` без
+ * узла (сам он не экспортирован). `done` — гидратацию сорвало расхождение или
+ * первое делегированное событие, и Solid снова пишет в узлы.
+ */
+export declare function hydrating(): boolean;
+/**
+ * Мемо, которое переживает окна гидратации: первое значение — `live`, а
+ * пересчёт в любом окне читает источники (`track`) и до конца окна отдаёт
+ * прежнее. Конец объявляет эффект, заведённый в этом пересчёте: Solid
+ * выполняет его, уже сняв контекст гидратации.
+ *
+ * `track` по умолчанию — сам `live`; петля только читает список, чтобы в окне
+ * не строить строк. Вычисление — функция над `source`, а не замыкание: мемо
+ * раскладки стоит у каждой строки таблицы.
+ */
+export declare function createHeldMemo<S, T>(source: S, live: (source: S) => T, track?: (source: S) => unknown): Accessor<T>;

package/dist/adapter/common/hydration.js

@@ -0,0 +1,44 @@
+import { createEffect, createMemo, createSignal, sharedConfig } from "solid-js";
+import { isServer } from "solid-js/web";
+//#region src/adapter/common/hydration.ts
+/**
+* Окна гидратации и мемо, которое их переживает: раскладка корня и частей
+* (`root.ts`), ветки и петли (`../runtime/flow.ts`, `KeyedFor`).
+* AGENTS.md (Solid), «Окна гидратации».
+*/
+/**
+* Открыто ли окно гидратации — условие `isHydrating` из `solid-js/web` без
+* узла (сам он не экспортирован). `done` — гидратацию сорвало расхождение или
+* первое делегированное событие, и Solid снова пишет в узлы.
+*/
+function hydrating() {
+	return !isServer && Boolean(sharedConfig.context) && !sharedConfig.done;
+}
+/** Метка «ещё не считали»: значение мемо бывает и пустым. */
+var UNCOMPUTED = Symbol("uncomputed");
+/** Конец окна — один сигнал на документ, как `sharedConfig` у Solid. */
+var [hydrationEnd, endHydration] = createSignal(void 0, { equals: false });
+function announceHydrationEnd() {
+	endHydration();
+}
+/**
+* Мемо, которое переживает окна гидратации: первое значение — `live`, а
+* пересчёт в любом окне читает источники (`track`) и до конца окна отдаёт
+* прежнее. Конец объявляет эффект, заведённый в этом пересчёте: Solid
+* выполняет его, уже сняв контекст гидратации.
+*
+* `track` по умолчанию — сам `live`; петля только читает список, чтобы в окне
+* не строить строк. Вычисление — функция над `source`, а не замыкание: мемо
+* раскладки стоит у каждой строки таблицы.
+*/
+function createHeldMemo(source, live, track = live) {
+	return createMemo((previous) => {
+		if (previous === UNCOMPUTED || !hydrating()) return live(source);
+		track(source);
+		hydrationEnd();
+		createEffect(announceHydrationEnd);
+		return previous;
+	}, UNCOMPUTED);
+}
+//#endregion
+export { createHeldMemo, hydrating };

package/dist/adapter/common/icon.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Иконка по роли — тег для `Icon`, аналог `roleIcon` у Vue. Атрибуты корня и
+ * `ref` ложатся на `<svg>`, тело иконки — `innerHTML` из доверенного пакета.
+ * Роль резолвится на отрисовке: `useIcons()` может прийти позже. Компонент на
+ * роль один, и `tag` с той же ролью корень не пересоздаёт.
+ */
+import type { Component, JSX } from 'solid-js';
+export type TRoleIconProps = JSX.SvgSVGAttributes<SVGSVGElement>;
+export declare function roleIcon(role: string): Component<TRoleIconProps>;

package/dist/adapter/common/icon.js

@@ -0,0 +1,28 @@
+import { getIcon } from "@soxa-ui/setup";
+import { mergeProps, spread, template } from "solid-js/web";
+//#region src/adapter/common/icon.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<svg>`);
+var icons = /* @__PURE__ */ new Map();
+function roleIcon(role) {
+	const known = icons.get(role);
+	if (known) return known;
+	function RoleIcon(props) {
+		const icon = getIcon(role);
+		return (() => {
+			var _el$ = _tmpl$();
+			spread(_el$, mergeProps(props, {
+				get viewBox() {
+					return icon.viewBox;
+				},
+				get innerHTML() {
+					return icon.body;
+				}
+			}), true, false);
+			return _el$;
+		})();
+	}
+	icons.set(role, RoleIcon);
+	return RoleIcon;
+}
+//#endregion
+export { roleIcon };

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

@@ -0,0 +1,9 @@
+export { SolidProfile } from './profile';
+export { SolidNaming } from './naming';
+export { createSolidAdapterContext } from './createSolidAdapterContext';
+export { renderSlot, hasSlot, resolveSlot, liveScope, relaySlot, type TSlotContent } from './slots';
+export { ResolvedSlot, type TResolvedSlotProps } from './ResolvedSlot';
+export { chainHandler, type THandlerUnion } from './handlers';
+export { clickAction } from './click-action';
+export { createPartProps, createRootProps, createWrappedRootProps, toControlAttrs, toPartClass, toRootForward, toRootLayout, toRootProps, toWrappedRootProps, type TRootForward, type TRootLayout, type TRootProps, type TRootSource, type TRootState, type TRootStyle, type TWrappedRootProps, type TWrappedRootSource, } from './root';
+export { roleIcon, type TRoleIconProps } from './icon';

package/dist/adapter/common/naming.d.ts

@@ -0,0 +1,3 @@
+import type { INamingStrategy } from '@soxa-ui/setup';
+/** Имена Solid: `iconStyles_styles`, события — колбэк-пропсы `onElementReady`. */
+export declare const SolidNaming: INamingStrategy;

package/dist/adapter/common/naming.js

@@ -0,0 +1,9 @@
+import { callbackEventNaming, underscorePropNaming } from "@soxa-ui/setup";
+//#region src/adapter/common/naming.ts
+/** Имена Solid: `iconStyles_styles`, события — колбэк-пропсы `onElementReady`. */
+var SolidNaming = {
+	prop: underscorePropNaming,
+	event: callbackEventNaming
+};
+//#endregion
+export { SolidNaming };

package/dist/adapter/common/profile.d.ts

@@ -0,0 +1,3 @@
+import type { IAdapterProfile } from '@soxa-ui/setup';
+/** Профиль связки (`adapter.connect()`): имена и слот по умолчанию `children`. */
+export declare const SolidProfile: IAdapterProfile;

package/dist/adapter/common/profile.js

@@ -0,0 +1,9 @@
+import { SolidNaming } from "./naming.js";
+//#region src/adapter/common/profile.ts
+/** Профиль связки (`adapter.connect()`): имена и слот по умолчанию `children`. */
+var SolidProfile = {
+	naming: SolidNaming,
+	defaultSlot: "children"
+};
+//#endregion
+export { SolidProfile };