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

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

@@ -0,0 +1,96 @@
+/**
+ * Раскладка корня: наборы ядра, атрибуты потребителя, класс и стиль — одна на
+ * все компоненты, как `toRootProps` у React и Svelte. `ref` в раскладку не
+ * входит: компонент ставит `ref` адаптера последним.
+ * AGENTS.md (Solid), «Раскладка корня» и «Окна гидратации».
+ */
+import type { Accessor, JSX } from 'solid-js';
+import type { TAttributesMap } from '@soxa-ui/core';
+/** Стиль, как его отдают плагины и ядро: имена — как в CSS (`z-index`, `--*`). */
+export type TRootStyle = Readonly<Record<string, string | number>>;
+/** Что корню нужно из состояния компонента. */
+export type TRootState = {
+    readonly classes?: readonly string[];
+    /** Выход плагина раскладки. */
+    readonly layout_styles?: TRootStyle;
+    /** Место элемента коллекции: ряд — флексбокс. */
+    readonly order?: number;
+    /** `false` прячет корень; ключа нет — корень виден всегда (Skeleton). */
+    readonly visible?: boolean;
+};
+/** Класс и стиль потребителя; стиль — объект свойств или строка. */
+export type TRootForward = {
+    readonly class?: string;
+    readonly style?: JSX.CSSProperties | string;
+};
+/** `ref` потребителя среди его атрибутов: корень ему отдаёт `ref` адаптера. */
+type TConsumerRefForward = {
+    readonly ref?: unknown;
+};
+export type TRootLayout = {
+    class: string;
+    /** Объект свойств; строка — только когда строкой пришёл стиль потребителя. */
+    style: TRootStyle | string;
+};
+/** Атрибуты корня целиком: наборы ядра, атрибуты потребителя и раскладка. */
+export type TRootProps = Record<string, unknown> & TRootLayout;
+/** Аргументы `toRootProps` — то, что читает мемо раскладки. */
+export type TRootSource = {
+    readonly state: TRootState;
+    /** Наборы ядра — в том порядке, в каком их кладёт Vue. */
+    readonly sets: readonly (TAttributesMap | undefined)[];
+    /** То, что не съела связка (`forwardProps`). */
+    readonly forward: TRootForward & TConsumerRefForward;
+    /** Стиль-выход компонента (`fractionStyle`). */
+    readonly style?: TRootStyle;
+};
+/** Обёртка корня и сам корень внутри неё — окно таблицы вокруг `table`. */
+export type TWrappedRootProps = {
+    readonly wrapper: TRootProps;
+    readonly root: TRootProps;
+};
+export type TWrappedRootSource = TRootSource & {
+    /** Класс обёртки: у окна таблицы `so-table__viewport`. */
+    readonly wrapper: string;
+};
+/**
+ * Класс и стиль корня. Стиль по слоям: раскладка, стиль-выход, `order`, затем
+ * потребитель, поверх всего — `display: none` скрытого. Строку потребителя
+ * разобрать негде (на сервере нет документа), и слои тогда склеиваются текстом.
+ */
+export declare function toRootLayout(state: TRootState, forward: TRootForward, style?: TRootStyle): TRootLayout;
+/** Наборы ядра, поверх — атрибуты потребителя без `ref`, затем класс и стиль. */
+export declare function toRootProps(state: TRootState, sets: readonly (TAttributesMap | undefined)[], forward: TRootForward & TConsumerRefForward, style?: TRootStyle): TRootProps;
+/**
+ * Атрибуты корня мемо — спред на корень:
+ * `<Root tag={state.tag} attributes={root} ref={binding.ref}>`.
+ */
+export declare function createRootProps(read: () => TRootSource): Accessor<TRootProps>;
+/**
+ * Атрибуты делятся, как у поля: обёртке — её класс, класс и стиль
+ * потребителя, скрытие; корню — остальное поверх наборов ядра. Состояние —
+ * поимённо: остаток деструктуризации прокси-состояния пуст.
+ */
+export declare function toWrappedRootProps(state: TRootState, sets: readonly (TAttributesMap | undefined)[], forward: TRootForward & TConsumerRefForward, wrapper: string, style?: TRootStyle): TWrappedRootProps;
+/**
+ * Обёртка и корень мемо: `<div {...layout().wrapper} ref={binding.consumerRef}>`,
+ * внутри `<Root tag={state.tag} attributes={() => layout().root} ref={binding.bindRef}>`.
+ */
+export declare function createWrappedRootProps(read: () => TWrappedRootSource): Accessor<TWrappedRootProps>;
+/** Класс и стиль потребителя — корню поля и окну таблицы. */
+export declare function toRootForward(forward: TRootForward): TRootForward;
+/** Классы части без своего экземпляра — строкой для `class` (панель Menu на Frame). */
+export declare function toPartClass(classes: readonly string[] | undefined): string;
+/**
+ * Атрибуты внутреннего узла — набор части или атрибуты контролу: вне
+ * гидратации само чтение, в ней — мемо, которое держит окна. Зовётся там, где
+ * узел рисуется, а не в выражении спреда; вызов на каждый набор.
+ */
+export declare function createPartProps<T extends object>(read: () => T | undefined): Accessor<T | undefined>;
+/**
+ * Атрибуты вложенного контрола: то, что не съела связка, без класса, стиля и
+ * `ref` — аналог `useSplitAttrs` у Vue. Параметр типа — атрибуты компонента:
+ * остаток сверяется с атрибутами узла, на который ложится.
+ */
+export declare function toControlAttrs<TAttributes extends TRootForward & TConsumerRefForward>(forward: Partial<TAttributes>): Omit<Partial<TAttributes>, keyof TRootForward | keyof TConsumerRefForward>;
+export {};

package/dist/adapter/common/root.js

@@ -0,0 +1,128 @@
+import { createHeldMemo, hydrating } from "./hydration.js";
+//#region src/adapter/common/root.ts
+var 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` скрытого. Строку потребителя
+* разобрать негде (на сервере нет документа), и слои тогда склеиваются текстом.
+*/
+function toRootLayout(state, forward, style) {
+	const below = [
+		...declarationsOf(state.layout_styles),
+		...declarationsOf(style),
+		...declarationsOf(state.order !== void 0 ? { order: state.order } : void 0)
+	];
+	const above = declarationsOf(state.visible === false ? HIDDEN : void 0);
+	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`, затем класс и стиль. */
+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}>`.
+*/
+function createRootProps(read) {
+	return createHeldMemo(read, rootPropsOf);
+}
+function rootPropsOf(read) {
+	const { state, sets, forward, style } = read();
+	return toRootProps(state, sets, forward, style);
+}
+/**
+* Атрибуты делятся, как у поля: обёртке — её класс, класс и стиль
+* потребителя, скрытие; корню — остальное поверх наборов ядра. Состояние —
+* поимённо: остаток деструктуризации прокси-состояния пуст.
+*/
+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}>`.
+*/
+function createWrappedRootProps(read) {
+	return createHeldMemo(read, wrappedRootPropsOf);
+}
+function wrappedRootPropsOf(read) {
+	const { state, sets, forward, wrapper, style } = read();
+	return toWrappedRootProps(state, sets, forward, wrapper, style);
+}
+/** Класс и стиль потребителя — корню поля и окну таблицы. */
+function toRootForward(forward) {
+	return {
+		class: forward.class,
+		style: forward.style
+	};
+}
+/** Классы части без своего экземпляра — строкой для `class` (панель Menu на Frame). */
+function toPartClass(classes) {
+	return classes?.join(" ") ?? "";
+}
+/**
+* Атрибуты внутреннего узла — набор части или атрибуты контролу: вне
+* гидратации само чтение, в ней — мемо, которое держит окна. Зовётся там, где
+* узел рисуется, а не в выражении спреда; вызов на каждый набор.
+*/
+function createPartProps(read) {
+	return hydrating() ? createHeldMemo(read, partPropsOf) : read;
+}
+function partPropsOf(read) {
+	return read();
+}
+/**
+* Атрибуты вложенного контрола: то, что не съела связка, без класса, стиля и
+* `ref` — аналог `useSplitAttrs` у Vue. Параметр типа — атрибуты компонента:
+* остаток сверяется с атрибутами узла, на который ложится.
+*/
+function toControlAttrs(forward) {
+	const { class: _class, style: _style, ref: _ref, ...control } = forward;
+	return control;
+}
+//#endregion
+export { createPartProps, createRootProps, createWrappedRootProps, toControlAttrs, toPartClass, toRootForward, toRootLayout, toRootProps, toWrappedRootProps };

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

@@ -0,0 +1,30 @@
+/**
+ * Слоты: готовые узлы или функция со scope. Функцию слота отличает арность:
+ * ленивое мемо компилятора — тоже функция, но без параметров. Scope функция
+ * получает живым (`liveScope`). AGENTS.md (Solid), «Слоты».
+ */
+import { type Accessor, type JSX } from 'solid-js';
+export type TSlotContent<TScope extends object = object> = JSX.Element | ((scope: TScope) => JSX.Element);
+export declare function renderSlot<TScope extends object = object>(content: TSlotContent<TScope> | undefined, scope?: TScope): JSX.Element;
+/** Передан ли слот: `undefined`, `null` и булево Solid не рисует. */
+export declare function hasSlot(content: unknown): boolean;
+/** Значение слота: геттер пропа прочитан, функция слота вызвана с живым scope. */
+export declare function slotValue<TScope extends object>(content: () => TSlotContent<TScope> | undefined, scope: () => TScope): JSX.Element | undefined;
+/**
+ * Слот, развёрнутый один раз, — аксессором; пустой по узлам — `undefined`.
+ * Так разметка выбирает запасное: `content() ?? state.text`. Геттер слота
+ * Solid на каждое чтение создаёт узлы заново, поэтому читают его один раз.
+ */
+export declare function resolveSlot<TScope extends object>(content: () => TSlotContent<TScope> | undefined, scope: () => TScope): Accessor<JSX.Element | undefined>;
+/**
+ * Живой scope — геттеры по ключам первого чтения: прочитанное в разметке слота
+ * следует за scope на месте, и функция слота не перезапускается на каждую
+ * смену (фокус и состояние внутри слота сохраняются).
+ */
+export declare function liveScope<TScope extends object>(scope: () => TScope): TScope;
+/**
+ * Проброс слота владельца коллекции в слот элемента: scope элемента плюс сам
+ * элемент (`extra`). Не задан — `undefined`, и элемент рисует своё. Scope
+ * выводится из слота элемента: `NoInfer` не даёт смотреть в слот владельца.
+ */
+export declare function relaySlot<TScope extends object, TExtra extends object>(content: TSlotContent<NoInfer<TScope & TExtra>> | undefined, extra: TExtra): ((scope: TScope) => JSX.Element) | undefined;

package/dist/adapter/common/slots.js

@@ -0,0 +1,75 @@
+import { children, untrack } from "solid-js";
+//#region src/adapter/common/slots.ts
+/**
+* Слоты: готовые узлы или функция со scope. Функцию слота отличает арность:
+* ленивое мемо компилятора — тоже функция, но без параметров. Scope функция
+* получает живым (`liveScope`). AGENTS.md (Solid), «Слоты».
+*/
+function isSlotFunction(content) {
+	return typeof content === "function" && content.length > 0;
+}
+function renderSlot(content, scope) {
+	if (isSlotFunction(content)) return content(scope ?? {});
+	return content;
+}
+/** Передан ли слот: `undefined`, `null` и булево Solid не рисует. */
+function hasSlot(content) {
+	return content !== void 0 && content !== null && typeof content !== "boolean";
+}
+/** Значение слота: геттер пропа прочитан, функция слота вызвана с живым scope. */
+function slotValue(content, scope) {
+	const value = content();
+	return isSlotFunction(value) ? value(liveScope(scope)) : value;
+}
+/**
+* Слот, развёрнутый один раз, — аксессором; пустой по узлам — `undefined`.
+* Так разметка выбирает запасное: `content() ?? state.text`. Геттер слота
+* Solid на каждое чтение создаёт узлы заново, поэтому читают его один раз.
+*/
+function resolveSlot(content, scope) {
+	const resolved = children(() => slotValue(content, scope));
+	return () => {
+		const nodes = resolved();
+		return hasSlot(nodes) ? nodes : void 0;
+	};
+}
+/**
+* Живой scope — геттеры по ключам первого чтения: прочитанное в разметке слота
+* следует за scope на месте, и функция слота не перезапускается на каждую
+* смену (фокус и состояние внутри слота сохраняются).
+*/
+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` не даёт смотреть в слот владельца.
+*/
+function relaySlot(content, extra) {
+	if (!hasSlot(content)) return void 0;
+	return (scope) => renderSlot(content, joinScope(scope, extra));
+}
+//#endregion
+export { hasSlot, liveScope, relaySlot, renderSlot, resolveSlot, slotValue };

package/dist/adapter/elevator/Elevate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Elevate — отдаёт детям слой лифта компонента, аналог `provide` у Vue.
+ * Пустой слой провайдера не ставит: `Provider` — эффект и мемо на узел, а
+ * флажок в каждой строке таблицы своего не опускает. AGENTS.md (Solid), «Лифт».
+ */
+import type { JSX } from 'solid-js';
+import { type TElevatorLayer } from './layer';
+export type TElevateProps = {
+    layer: TElevatorLayer;
+    children?: JSX.Element;
+};
+export declare function Elevate(props: TElevateProps): JSX.Element;

package/dist/adapter/elevator/Elevate.js

@@ -0,0 +1,16 @@
+import { ElevatorContext } from "./layer.js";
+import { createComponent } from "solid-js/web";
+//#region src/adapter/elevator/Elevate.tsx
+function Elevate(props) {
+	if (props.layer.empty) return props.children;
+	return createComponent(ElevatorContext.Provider, {
+		get value() {
+			return props.layer;
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+//#endregion
+export { Elevate };

package/dist/adapter/elevator/elevator.class.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Лифт одного ключа поверх слоёв сборки: `up()` читает слой предка, `down()`
+ * пишет в слой компонента. AGENTS.md (Solid), «Лифт».
+ */
+import { TElevator } from '@soxa-ui/setup';
+import type { TElevatorLayer } from './layer';
+export declare class TSolidElevator<T = unknown> extends TElevator<T> {
+    private readonly _parent;
+    private readonly _own;
+    /**
+     * @param _parent слой предка; вне владельцев — `undefined`
+     * @param _own слой компонента
+     */
+    constructor(key: string | symbol, _parent: TElevatorLayer | undefined, _own: TElevatorLayer);
+    down(value: T): void;
+    up(): T | undefined;
+}

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

@@ -0,0 +1,27 @@
+import { TElevator } from "@soxa-ui/setup";
+//#region src/adapter/elevator/elevator.class.ts
+/**
+* Лифт одного ключа поверх слоёв сборки: `up()` читает слой предка, `down()`
+* пишет в слой компонента. AGENTS.md (Solid), «Лифт».
+*/
+var TSolidElevator = class 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() {
+		return this._parent?.read(this._key);
+	}
+};
+//#endregion
+export { TSolidElevator };

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

@@ -0,0 +1,4 @@
+export { TSolidElevator } from './elevator.class';
+export { Elevate, type TElevateProps } from './Elevate';
+export { useElevator, type TElevation } from './useElevator';
+export type { TElevatorLayer } from './layer';

package/dist/adapter/elevator/layer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Слой лифта — значения владельца его поддереву, свои поверх слоя предка.
+ * Контекст Solid один на все ключи, как у React и Angular. AGENTS.md (Solid), «Лифт».
+ */
+export declare class TElevatorLayer {
+    private readonly _parent;
+    private readonly _own;
+    /** @param _parent слой ближайшего владельца выше; нет его — `undefined` */
+    constructor(_parent: TElevatorLayer | undefined);
+    /** Своё значение, а нет его — слоя предка. Опущенный `null` — тоже значение. */
+    read(key: symbol): unknown;
+    write(key: symbol, value: unknown): void;
+    /** Своих значений нет: `Elevate` детям слой не отдаёт. */
+    get empty(): boolean;
+}
+export declare const ElevatorContext: import("solid-js").Context<TElevatorLayer | undefined>;

package/dist/adapter/elevator/layer.js

@@ -0,0 +1,28 @@
+import { createContext } from "solid-js";
+//#region src/adapter/elevator/layer.ts
+/**
+* Слой лифта — значения владельца его поддереву, свои поверх слоя предка.
+* Контекст Solid один на все ключи, как у React и Angular. AGENTS.md (Solid), «Лифт».
+*/
+var TElevatorLayer = class {
+	_parent;
+	_own = /* @__PURE__ */ 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;
+	}
+};
+var ElevatorContext = createContext(void 0);
+//#endregion
+export { ElevatorContext, TElevatorLayer };

package/dist/adapter/elevator/useElevator.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Лифт сборки: фабрика лифтов для расширений и слой компонента, который детям
+ * отдаёт `Elevate`. Зовётся в теле компонента — контекст Solid читается только
+ * тогда. AGENTS.md (Solid), «Лифт».
+ */
+import type { TElevatorFactory } from '@soxa-ui/setup';
+import { TElevatorLayer } from './layer';
+export type TElevation = {
+    readonly elevator: TElevatorFactory;
+    /** Слой компонента: свой поверх слоя предка. Детям — через `Elevate`. */
+    readonly layer: TElevatorLayer;
+};
+export declare function useElevator(): TElevation;

package/dist/adapter/elevator/useElevator.js

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

package/dist/adapter/index.d.ts

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

package/dist/adapter/locale/LocaleProvider.d.ts

@@ -0,0 +1,22 @@
+import { type JSX } from 'solid-js';
+import type { TLocale } from '@soxa-ui/plugins';
+export type TLocaleProviderProps = {
+    /** Локаль поддерева: тег для Intl и строки библиотеки (`ruRU`, `extendLocale(...)`) */
+    locale: TLocale;
+    children?: JSX.Element;
+};
+/**
+ * LocaleProvider — локаль поддерева: язык и строки библиотеки компонентам
+ * внутри.
+ *
+ * ```tsx
+ * <LocaleProvider locale={current()}>
+ * 	<App />
+ * </LocaleProvider>
+ * ```
+ *
+ * Источник свой на провайдер (сервер рисует запросы каждый на своём языке) и
+ * создаётся с локалью первой отрисовки; смена пропа идёт в тот же источник,
+ * компоненты не перемонтируются.
+ */
+export declare function LocaleProvider(props: TLocaleProviderProps): JSX.Element;

package/dist/adapter/locale/LocaleProvider.js

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

package/dist/adapter/locale/context.d.ts

@@ -0,0 +1,4 @@
+import type { ILocaleSource } from '@soxa-ui/plugins';
+export declare const LocaleContext: import("solid-js").Context<ILocaleSource | undefined>;
+/** Источник ближайшего `LocaleProvider`; нет его — у набора своя английская. */
+export declare function nearestLocale(): ILocaleSource | undefined;

package/dist/adapter/locale/context.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "solid-js";
+//#region src/adapter/locale/context.ts
+var LocaleContext = createContext(void 0);
+/** Источник ближайшего `LocaleProvider`; нет его — у набора своя английская. */
+function nearestLocale() {
+	return useContext(LocaleContext);
+}
+//#endregion
+export { LocaleContext, nearestLocale };

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * Петля по ключу записи: узел живёт, пока в списке есть запись с его ключом,
+ * а новую запись получает аксессором. `drawn` коллекции — новые записи на
+ * каждую смену, и `<For>` по ссылке пересоздавал бы строки вместе с фокусом.
+ * Окна гидратации переживает, как `flow.ts`. AGENTS.md (Solid), «Ветки и петли».
+ */
+import { type Accessor, type JSX } from 'solid-js';
+export type TKeyedForProps<TEntry, TKey> = {
+    each: readonly TEntry[] | undefined;
+    /** Ключ записи: у записей одного узла он один и тот же. */
+    by: (entry: TEntry) => TKey;
+    children: (entry: Accessor<TEntry>) => JSX.Element;
+};
+export declare function KeyedFor<TEntry, TKey>(props: TKeyedForProps<TEntry, TKey>): JSX.Element;

package/dist/adapter/runtime/KeyedFor.js

@@ -0,0 +1,54 @@
+import { createHeldMemo } from "../common/hydration.js";
+import { createRoot, createSignal, onCleanup, untrack } from "solid-js";
+//#region src/adapter/runtime/KeyedFor.tsx
+/**
+* Петля по ключу записи: узел живёт, пока в списке есть запись с его ключом,
+* а новую запись получает аксессором. `drawn` коллекции — новые записи на
+* каждую смену, и `<For>` по ссылке пересоздавал бы строки вместе с фокусом.
+* Окна гидратации переживает, как `flow.ts`. AGENTS.md (Solid), «Ветки и петли».
+*/
+/** Строка петли — объект, а не замыкание на строку: строк тысячи (ячейки таблицы). */
+var TRow = class {
+	node;
+	_write;
+	dispose;
+	constructor(node, _write, dispose) {
+		this.node = node;
+		this._write = _write;
+		this.dispose = dispose;
+	}
+	update(entry) {
+		this._write(() => entry);
+	}
+};
+function KeyedFor(props) {
+	const rows = /* @__PURE__ */ 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 = /* @__PURE__ */ 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;
+	});
+	return createHeldMemo(props, (source) => reconcile(source.each ?? []), (source) => source.each);
+}
+//#endregion
+export { KeyedFor };