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

package/dist/index.js

@@ -0,0 +1,60 @@
+import { roleIcon } from "./adapter/common/icon.js";
+import { LocaleProvider } from "./adapter/locale/LocaleProvider.js";
+import { useToasts } from "./adapter/toasts/useToasts.js";
+import { ComponentView } from "./components/component-view/ComponentView.js";
+import { Button } from "./components/button/Button.js";
+import { Icon } from "./components/icon/Icon.js";
+import { Label } from "./components/label/Label.js";
+import { Field } from "./components/field/Field.js";
+import { Frame } from "./components/frame/Frame.js";
+import { Popover } from "./components/popover/Popover.js";
+import { Tooltip } from "./components/tooltip/Tooltip.js";
+import { Dialog } from "./components/dialog/Dialog.js";
+import { Drawer } from "./components/drawer/Drawer.js";
+import { ProgressSpinner } from "./components/progress-spinner/ProgressSpinner.js";
+import { Toasts } from "./components/toasts/Toasts.js";
+import { MenuGroup } from "./components/menu/group/Group.js";
+import { MenuItem } from "./components/menu/item/Item.js";
+import { MenuSeparator } from "./components/menu/separator/Separator.js";
+import { MenuSubmenu } from "./components/menu/submenu/Submenu.js";
+import { MenuCheckboxItem } from "./components/menu/checkbox-item/CheckboxItem.js";
+import { MenuRadioItem } from "./components/menu/radio-item/RadioItem.js";
+import { MenuPopoverItem } from "./components/menu/popover-item/PopoverItem.js";
+import { MenuRadioGroup } from "./components/menu/radio-group/RadioGroup.js";
+import { Menu } from "./components/menu/index.js";
+import { ProgressLinear } from "./components/progress-linear/ProgressLinear.js";
+import { Skeleton } from "./components/skeleton/Skeleton.js";
+import { Input } from "./components/input/Input.js";
+import { NumberInput } from "./components/number-input/NumberInput.js";
+import { DateInput } from "./components/date-input/DateInput.js";
+import { Textarea } from "./components/textarea/Textarea.js";
+import { CheckBox } from "./components/check-box/CheckBox.js";
+import { Switch } from "./components/switch/Switch.js";
+import { Slider } from "./components/slider/Slider.js";
+import { Rating } from "./components/rating/Rating.js";
+import { RadioGroupItem } from "./components/radio-group/item/Item.js";
+import { RadioGroup } from "./components/radio-group/index.js";
+import { ListBoxItem } from "./components/list-box/item/Item.js";
+import { ListBoxGroup } from "./components/list-box/group/Group.js";
+import { ListBox } from "./components/list-box/index.js";
+import { TabsItem } from "./components/tabs/item/Item.js";
+import { TabsContent } from "./components/tabs/content/Content.js";
+import { Tabs } from "./components/tabs/index.js";
+import { TagsItem } from "./components/tags/item/Item.js";
+import { Tags } from "./components/tags/index.js";
+import { SelectItem } from "./components/select/item/Item.js";
+import { SelectGroup } from "./components/select/group/Group.js";
+import { Select } from "./components/select/index.js";
+import { CalendarItem } from "./components/calendar/item/Item.js";
+import { Calendar } from "./components/calendar/index.js";
+import { DatePicker } from "./components/date-picker/DatePicker.js";
+import { AccordionItem } from "./components/accordion/item/Item.js";
+import { Accordion } from "./components/accordion/index.js";
+import { Pagination } from "./components/pagination/Pagination.js";
+import { Scroller } from "./components/scroller/Scroller.js";
+import { TableColumn } from "./components/table/column/Column.js";
+import { TableRow } from "./components/table/row/Row.js";
+import { Table } from "./components/table/index.js";
+import { Virtual } from "./components/virtual/Virtual.js";
+import { DragAndDrop } from "./components/drag-and-drop/DragAndDrop.js";
+export { Accordion, AccordionItem, Button, Calendar, CalendarItem, CheckBox, ComponentView, DateInput, DatePicker, Dialog, DragAndDrop, Drawer, Field, Frame, Icon, Input, Label, ListBox, ListBoxGroup, ListBoxItem, LocaleProvider, Menu, MenuCheckboxItem, MenuGroup, MenuItem, MenuPopoverItem, MenuRadioGroup, MenuRadioItem, MenuSeparator, MenuSubmenu, NumberInput, Pagination, Popover, ProgressLinear, ProgressSpinner, RadioGroup, RadioGroupItem, Rating, Scroller, Select, SelectGroup, SelectItem, Skeleton, Slider, Switch, Table, TableColumn, TableRow, Tabs, TabsContent, TabsItem, Tags, TagsItem, Textarea, Toasts, Tooltip, Virtual, roleIcon, useToasts };

package/dist/source/adapter/common/ResolvedSlot.jsx

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

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

@@ -0,0 +1,8 @@
+/**
+ * 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 function clickAction(action) {
+    return (node) => node.addEventListener('click', action);
+}

package/dist/source/adapter/common/createSolidAdapterContext.js

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

package/dist/source/adapter/common/handlers.js

@@ -0,0 +1,13 @@
+/**
+ * Своё, затем обработчик потребителя — на одном событии разметки: в Solid
+ * событие — проп, и обработчик потребителя занял бы место своего.
+ */
+export function chainHandler(own, consumer) {
+    return (event) => {
+        own(event);
+        if (typeof consumer === 'function')
+            consumer(event);
+        else
+            consumer?.[0](consumer[1], event);
+    };
+}

package/dist/source/adapter/common/hydration.js

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

package/dist/source/adapter/common/icon.jsx

@@ -0,0 +1,19 @@
+/**
+ * Иконка по роли — тег для `Icon`, аналог `roleIcon` у Vue. Атрибуты корня и
+ * `ref` ложатся на `<svg>`, тело иконки — `innerHTML` из доверенного пакета.
+ * Роль резолвится на отрисовке: `useIcons()` может прийти позже. Компонент на
+ * роль один, и `tag` с той же ролью корень не пересоздаёт.
+ */
+import { getIcon } from '@soxa-ui/setup';
+const icons = new Map();
+export function roleIcon(role) {
+    const known = icons.get(role);
+    if (known)
+        return known;
+    function RoleIcon(props) {
+        const icon = getIcon(role);
+        return <svg {...props} viewBox={icon.viewBox} innerHTML={icon.body}/>;
+    }
+    icons.set(role, RoleIcon);
+    return RoleIcon;
+}

package/dist/source/adapter/common/index.js

@@ -0,0 +1,9 @@
+export { SolidProfile } from './profile';
+export { SolidNaming } from './naming';
+export { createSolidAdapterContext } from './createSolidAdapterContext';
+export { renderSlot, hasSlot, resolveSlot, liveScope, relaySlot } from './slots';
+export { ResolvedSlot } from './ResolvedSlot';
+export { chainHandler } from './handlers';
+export { clickAction } from './click-action';
+export { createPartProps, createRootProps, createWrappedRootProps, toControlAttrs, toPartClass, toRootForward, toRootLayout, toRootProps, toWrappedRootProps, } from './root';
+export { roleIcon } from './icon';

package/dist/source/adapter/common/naming.js

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

package/dist/source/adapter/common/profile.js

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

package/dist/source/adapter/common/root.js

@@ -0,0 +1,113 @@
+/**
+ * Раскладка корня: наборы ядра, атрибуты потребителя, класс и стиль — одна на
+ * все компоненты, как `toRootProps` у React и Svelte. `ref` в раскладку не
+ * входит: компонент ставит `ref` адаптера последним.
+ * AGENTS.md (Solid), «Раскладка корня» и «Окна гидратации».
+ */
+import { createHeldMemo, hydrating } from './hydration';
+const HIDDEN = { display: 'none' };
+/** Свойства слоя стиля без пустых: `''` свойства не задаёт. */
+function declarationsOf(styles) {
+    const declarations = [];
+    for (const [name, value] of Object.entries(styles ?? {})) {
+        if (typeof value === 'number' || (typeof value === 'string' && value !== '')) {
+            declarations.push([name, value]);
+        }
+    }
+    return declarations;
+}
+function toCssText(declarations) {
+    return declarations.map(([name, value]) => `${name}: ${value}`);
+}
+/**
+ * Класс и стиль корня. Стиль по слоям: раскладка, стиль-выход, `order`, затем
+ * потребитель, поверх всего — `display: none` скрытого. Строку потребителя
+ * разобрать негде (на сервере нет документа), и слои тогда склеиваются текстом.
+ */
+export function toRootLayout(state, forward, style) {
+    const below = [
+        ...declarationsOf(state.layout_styles),
+        ...declarationsOf(style),
+        ...declarationsOf(state.order !== undefined ? { order: state.order } : undefined),
+    ];
+    const above = declarationsOf(state.visible === false ? HIDDEN : undefined);
+    const className = [...(state.classes ?? []), forward.class].filter(Boolean).join(' ');
+    const consumer = forward.style;
+    if (typeof consumer === 'string' && consumer !== '') {
+        return {
+            class: className,
+            style: [...toCssText(below), consumer, ...toCssText(above)].join('; '),
+        };
+    }
+    const own = typeof consumer === 'object' ? declarationsOf(consumer) : [];
+    return { class: className, style: Object.fromEntries([...below, ...own, ...above]) };
+}
+/** Наборы ядра, поверх — атрибуты потребителя без `ref`, затем класс и стиль. */
+export function toRootProps(state, sets, forward, style) {
+    const attributes = {};
+    for (const set of sets)
+        Object.assign(attributes, set);
+    const { ref: _ref, ...consumer } = forward;
+    return { ...attributes, ...consumer, ...toRootLayout(state, forward, style) };
+}
+/**
+ * Атрибуты корня мемо — спред на корень:
+ * `<Root tag={state.tag} attributes={root} ref={binding.ref}>`.
+ */
+export function createRootProps(read) {
+    return createHeldMemo(read, rootPropsOf);
+}
+function rootPropsOf(read) {
+    const { state, sets, forward, style } = read();
+    return toRootProps(state, sets, forward, style);
+}
+/**
+ * Атрибуты делятся, как у поля: обёртке — её класс, класс и стиль
+ * потребителя, скрытие; корню — остальное поверх наборов ядра. Состояние —
+ * поимённо: остаток деструктуризации прокси-состояния пуст.
+ */
+export function toWrappedRootProps(state, sets, forward, wrapper, style) {
+    return {
+        wrapper: toRootProps({ classes: [wrapper], visible: state.visible }, [], toRootForward(forward)),
+        root: toRootProps({ classes: state.classes, layout_styles: state.layout_styles, order: state.order }, sets, toControlAttrs(forward), style),
+    };
+}
+/**
+ * Обёртка и корень мемо: `<div {...layout().wrapper} ref={binding.consumerRef}>`,
+ * внутри `<Root tag={state.tag} attributes={() => layout().root} ref={binding.bindRef}>`.
+ */
+export function createWrappedRootProps(read) {
+    return createHeldMemo(read, wrappedRootPropsOf);
+}
+function wrappedRootPropsOf(read) {
+    const { state, sets, forward, wrapper, style } = read();
+    return toWrappedRootProps(state, sets, forward, wrapper, style);
+}
+/** Класс и стиль потребителя — корню поля и окну таблицы. */
+export function toRootForward(forward) {
+    return { class: forward.class, style: forward.style };
+}
+/** Классы части без своего экземпляра — строкой для `class` (панель Menu на Frame). */
+export function toPartClass(classes) {
+    return classes?.join(' ') ?? '';
+}
+/**
+ * Атрибуты внутреннего узла — набор части или атрибуты контролу: вне
+ * гидратации само чтение, в ней — мемо, которое держит окна. Зовётся там, где
+ * узел рисуется, а не в выражении спреда; вызов на каждый набор.
+ */
+export function createPartProps(read) {
+    return hydrating() ? createHeldMemo(read, partPropsOf) : read;
+}
+function partPropsOf(read) {
+    return read();
+}
+/**
+ * Атрибуты вложенного контрола: то, что не съела связка, без класса, стиля и
+ * `ref` — аналог `useSplitAttrs` у Vue. Параметр типа — атрибуты компонента:
+ * остаток сверяется с атрибутами узла, на который ложится.
+ */
+export function toControlAttrs(forward) {
+    const { class: _class, style: _style, ref: _ref, ...control } = forward;
+    return control;
+}

package/dist/source/adapter/common/slots.js

@@ -0,0 +1,74 @@
+/**
+ * Слоты: готовые узлы или функция со scope. Функцию слота отличает арность:
+ * ленивое мемо компилятора — тоже функция, но без параметров. Scope функция
+ * получает живым (`liveScope`). AGENTS.md (Solid), «Слоты».
+ */
+import { children, untrack } from 'solid-js';
+function isSlotFunction(content) {
+    return typeof content === 'function' && content.length > 0;
+}
+export function renderSlot(content, scope) {
+    if (isSlotFunction(content))
+        return content((scope ?? {}));
+    return content;
+}
+/** Передан ли слот: `undefined`, `null` и булево Solid не рисует. */
+export function hasSlot(content) {
+    return content !== undefined && content !== null && typeof content !== 'boolean';
+}
+/** Значение слота: геттер пропа прочитан, функция слота вызвана с живым scope. */
+export function slotValue(content, scope) {
+    const value = content();
+    return isSlotFunction(value) ? value(liveScope(scope)) : value;
+}
+/**
+ * Слот, развёрнутый один раз, — аксессором; пустой по узлам — `undefined`.
+ * Так разметка выбирает запасное: `content() ?? state.text`. Геттер слота
+ * Solid на каждое чтение создаёт узлы заново, поэтому читают его один раз.
+ */
+export function resolveSlot(content, scope) {
+    const resolved = children(() => slotValue(content, scope));
+    return () => {
+        const nodes = resolved();
+        return hasSlot(nodes) ? nodes : undefined;
+    };
+}
+/**
+ * Живой scope — геттеры по ключам первого чтения: прочитанное в разметке слота
+ * следует за scope на месте, и функция слота не перезапускается на каждую
+ * смену (фокус и состояние внутри слота сохраняются).
+ */
+export function liveScope(scope) {
+    const first = untrack(scope);
+    const live = { ...first };
+    for (const key of Object.keys(first)) {
+        Object.defineProperty(live, key, {
+            enumerable: true,
+            get: () => Reflect.get(scope(), key),
+        });
+    }
+    return live;
+}
+/** Scope элемента живыми полями, поверх — `extra`, как `{ ...scope, ...extra }`. */
+function joinScope(scope, extra) {
+    const joined = untrack(() => ({ ...scope, ...extra }));
+    for (const key of Object.keys(scope)) {
+        if (Object.hasOwn(extra, key))
+            continue;
+        Object.defineProperty(joined, key, {
+            enumerable: true,
+            get: () => Reflect.get(scope, key),
+        });
+    }
+    return joined;
+}
+/**
+ * Проброс слота владельца коллекции в слот элемента: scope элемента плюс сам
+ * элемент (`extra`). Не задан — `undefined`, и элемент рисует своё. Scope
+ * выводится из слота элемента: `NoInfer` не даёт смотреть в слот владельца.
+ */
+export function relaySlot(content, extra) {
+    if (!hasSlot(content))
+        return undefined;
+    return (scope) => renderSlot(content, joinScope(scope, extra));
+}

package/dist/source/adapter/elevator/Elevate.jsx

@@ -0,0 +1,11 @@
+/**
+ * Elevate — отдаёт детям слой лифта компонента, аналог `provide` у Vue.
+ * Пустой слой провайдера не ставит: `Provider` — эффект и мемо на узел, а
+ * флажок в каждой строке таблицы своего не опускает. AGENTS.md (Solid), «Лифт».
+ */
+import { ElevatorContext } from './layer';
+export function Elevate(props) {
+    if (props.layer.empty)
+        return props.children;
+    return <ElevatorContext.Provider value={props.layer}>{props.children}</ElevatorContext.Provider>;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Лифт одного ключа поверх слоёв сборки: `up()` читает слой предка, `down()`
+ * пишет в слой компонента. AGENTS.md (Solid), «Лифт».
+ */
+import { TElevator } from '@soxa-ui/setup';
+export class TSolidElevator extends TElevator {
+    _parent;
+    _own;
+    /**
+     * @param _parent слой предка; вне владельцев — `undefined`
+     * @param _own слой компонента
+     */
+    constructor(key, _parent, _own) {
+        super(key);
+        this._parent = _parent;
+        this._own = _own;
+    }
+    down(value) {
+        this._own.write(this._key, value);
+    }
+    up() {
+        // Тип значения задаёт ключ лифта: под этим ключом кладут только `T`
+        return this._parent?.read(this._key);
+    }
+}

package/dist/source/adapter/elevator/index.js

@@ -0,0 +1,3 @@
+export { TSolidElevator } from './elevator.class';
+export { Elevate } from './Elevate';
+export { useElevator } from './useElevator';

package/dist/source/adapter/elevator/layer.js

@@ -0,0 +1,25 @@
+/**
+ * Слой лифта — значения владельца его поддереву, свои поверх слоя предка.
+ * Контекст Solid один на все ключи, как у React и Angular. AGENTS.md (Solid), «Лифт».
+ */
+import { createContext } from 'solid-js';
+export class TElevatorLayer {
+    _parent;
+    _own = new Map();
+    /** @param _parent слой ближайшего владельца выше; нет его — `undefined` */
+    constructor(_parent) {
+        this._parent = _parent;
+    }
+    /** Своё значение, а нет его — слоя предка. Опущенный `null` — тоже значение. */
+    read(key) {
+        return this._own.has(key) ? this._own.get(key) : this._parent?.read(key);
+    }
+    write(key, value) {
+        this._own.set(key, value);
+    }
+    /** Своих значений нет: `Elevate` детям слой не отдаёт. */
+    get empty() {
+        return this._own.size === 0;
+    }
+}
+export const ElevatorContext = createContext(undefined);

package/dist/source/adapter/elevator/useElevator.js

@@ -0,0 +1,16 @@
+/**
+ * Лифт сборки: фабрика лифтов для расширений и слой компонента, который детям
+ * отдаёт `Elevate`. Зовётся в теле компонента — контекст Solid читается только
+ * тогда. AGENTS.md (Solid), «Лифт».
+ */
+import { useContext } from 'solid-js';
+import { TSolidElevator } from './elevator.class';
+import { ElevatorContext, TElevatorLayer } from './layer';
+export function useElevator() {
+    const parent = useContext(ElevatorContext);
+    const layer = new TElevatorLayer(parent);
+    return {
+        elevator: (key) => new TSolidElevator(key.name, parent, layer),
+        layer,
+    };
+}

package/dist/source/adapter/index.js

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

package/dist/source/adapter/locale/LocaleProvider.jsx

@@ -0,0 +1,24 @@
+import { createRenderEffect, untrack } from 'solid-js';
+import { TLocaleSource } from '@soxa-ui/plugins';
+import { LocaleContext } from './context';
+/**
+ * LocaleProvider — локаль поддерева: язык и строки библиотеки компонентам
+ * внутри.
+ *
+ * ```tsx
+ * <LocaleProvider locale={current()}>
+ * 	<App />
+ * </LocaleProvider>
+ * ```
+ *
+ * Источник свой на провайдер (сервер рисует запросы каждый на своём языке) и
+ * создаётся с локалью первой отрисовки; смена пропа идёт в тот же источник,
+ * компоненты не перемонтируются.
+ */
+export function LocaleProvider(props) {
+    const source = new TLocaleSource(untrack(() => props.locale));
+    createRenderEffect(() => {
+        source.locale = props.locale;
+    });
+    return <LocaleContext.Provider value={source}>{props.children}</LocaleContext.Provider>;
+}

package/dist/source/adapter/locale/context.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'solid-js';
+export const LocaleContext = createContext(undefined);
+/** Источник ближайшего `LocaleProvider`; нет его — у набора своя английская. */
+export function nearestLocale() {
+    return useContext(LocaleContext);
+}

package/dist/source/adapter/locale/index.js

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

package/dist/source/adapter/runtime/KeyedFor.jsx

@@ -0,0 +1,60 @@
+/**
+ * Петля по ключу записи: узел живёт, пока в списке есть запись с его ключом,
+ * а новую запись получает аксессором. `drawn` коллекции — новые записи на
+ * каждую смену, и `<For>` по ссылке пересоздавал бы строки вместе с фокусом.
+ * Окна гидратации переживает, как `flow.ts`. AGENTS.md (Solid), «Ветки и петли».
+ */
+import { createRoot, createSignal, onCleanup, untrack, } from 'solid-js';
+import { createHeldMemo } from '../common/hydration';
+/** Строка петли — объект, а не замыкание на строку: строк тысячи (ячейки таблицы). */
+class TRow {
+    node;
+    _write;
+    dispose;
+    constructor(node, _write, dispose) {
+        this.node = node;
+        this._write = _write;
+        this.dispose = dispose;
+    }
+    update(entry) {
+        // Запись-функцию сеттер сигнала счёл бы updater'ом
+        this._write(() => entry);
+    }
+}
+export function KeyedFor(props) {
+    const rows = new Map();
+    // Строка — в своём корне под владельцем петли: контекст места тот же
+    const createRow = (entry) => createRoot((dispose) => {
+        const [current, write] = createSignal(entry);
+        return new TRow(props.children(current), write, dispose);
+    });
+    onCleanup(() => {
+        for (const row of rows.values())
+            row.dispose();
+        rows.clear();
+    });
+    // Узлы и ключи — не зависимости петли: она идёт только за списком
+    const reconcile = (entries) => untrack(() => {
+        const seen = new Set();
+        const result = entries.map((entry) => {
+            const key = props.by(entry);
+            let row = rows.get(key);
+            if (row)
+                row.update(entry);
+            else
+                rows.set(key, (row = createRow(entry)));
+            seen.add(key);
+            return row.node;
+        });
+        for (const [key, row] of rows) {
+            if (seen.has(key))
+                continue;
+            row.dispose();
+            rows.delete(key);
+        }
+        return result;
+    });
+    const nodes = createHeldMemo(props, (source) => reconcile(source.each ?? []), (source) => source.each);
+    // Само мемо, а не фрагмент: фрагмент над ним — ещё мемо на каждую петлю
+    return nodes;
+}