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

package/dist/protected/define/plugin.js

@@ -0,0 +1,20 @@
+import { normalizeContribution } from "./contribution.js";
+import { TPluginDefinition } from "./plugin-definition.class.js";
+//#region protected/define/plugin.ts
+var contracts = /* @__PURE__ */ new WeakMap();
+/**
+* Параметры типа выводятся из опций, явно их не передают. Неймспейс и
+* contribution — `const`: из их литералов складываются имена в контракте.
+*/
+function definePlugin(options) {
+	const { props, events } = normalizeContribution(options.contribution, options.namespace);
+	const definition = new TPluginDefinition(options.ctor, options.namespace, props, events);
+	contracts.set(options.ctor, definition);
+	return definition;
+}
+/** Контракт плагина — его объявление `definePlugin`; нет — пропсов и событий у плагина нет. */
+function pluginContractOf(ctor) {
+	return contracts.get(ctor);
+}
+//#endregion
+export { definePlugin, pluginContractOf };

package/dist/protected/define/prop-spec.class.d.ts

@@ -0,0 +1,70 @@
+/**
+ * TPropSpec — неизменяемое описание свойства: одна запись на тип, которую делят все монтирования.
+ *
+ * Приспособленец (Flyweight): в описании нет ни владельца, ни памяти — только
+ * то, что верно для типа. Но оно не анемично: как прочитать и как записать
+ * свойство у владельца, знает само описание, поэтому `get`/`set` объявления
+ * больше нигде не разбираются. Владельца к описанию приставляет линия обмена
+ * (`TLine`) на время монтирования.
+ *
+ * **Умолчание: значим ключ, а не значение.** Поля `default` у описания нет
+ * вовсе, пока умолчание не объявлено; `closable: undefined` у `TTabsItem` —
+ * это «объявлено и равно `undefined`» («как у владельца»). Проверка
+ * `default !== undefined` сломала бы этот случай молча, поэтому спрашивают
+ * `hasDefault` (или `Object.hasOwn(spec, 'default')` — так читает стенд).
+ *
+ * Умолчание принадлежит классу владельца, а не объявлению, поэтому наследник
+ * дескриптора и `with()` плагина получают своё описание — `rebase` и
+ * `withDefault` возвращают новый объект, исходный не меняется: его делят
+ * родитель и все, кто от него наследуется.
+ *
+ * По той же разнице «ключ есть / ключа нет» описание переобъявляется:
+ * `inheritFrom` кладёт объявление наследника на родительское, и написанные
+ * факты побеждают, а ненаписанные остаются родительскими. Это правило самого
+ * описания — общий контракт наследования (`IDeclaration`) у него с
+ * определением плагина, а складывает списки `inheritDeclarations`.
+ */
+import type { IPropDefinition } from './contribution.types';
+import type { TName } from './name.class';
+import type { IDeclaration } from './types';
+export declare class TPropSpec implements IDeclaration<TPropSpec> {
+    readonly name: TName;
+    readonly triggers: readonly TName[];
+    private readonly _definition;
+    readonly type: unknown;
+    readonly protected: boolean;
+    /** Ключ есть, только если умолчание объявлено. */
+    readonly default?: unknown;
+    /**
+     * @param _definition объявление из contribution: из него берутся `get` и `set`
+     * @param defaults умолчания класса владельца; нет ключа с именем пропа — нет и умолчания
+     */
+    constructor(name: TName, triggers: readonly TName[], _definition: IPropDefinition, defaults?: Readonly<Record<string, unknown>>);
+    get hasDefault(): boolean;
+    /** Ключ наследования — полное имя: по нему свойство находят и во фреймворке, и в ядре. */
+    get key(): string;
+    /** Свои `get`/`set` объявления — для интроспекции; читать и писать надо через `read`/`assign`. */
+    get get(): IPropDefinition['get'];
+    get set(): IPropDefinition['set'];
+    /** Прочитать у владельца: `get` объявления, а без него `owner[name]`; составное — снимком. */
+    read(owner: object): unknown;
+    /** Записать владельцу: `set` объявления, а без него сеттер `owner[name]`. */
+    assign(owner: object, value: unknown): void;
+    /** То же описание с умолчанием от другого класса: наследник пересчитывает, а не копирует. */
+    rebase(defaults: Readonly<Record<string, unknown>> | undefined): TPropSpec;
+    /**
+     * Своё описание поверх одноимённого родительского: переобъявлены ровно те
+     * факты, которые автор написал, остальные — родительские.
+     *
+     * Значим ключ объявления, а не значение, как у умолчания: `protected: true`
+     * у элемента коллекции снимает вход, а `type` и `triggers` остаются
+     * объявленными один раз, у того, кто проп завёл. Ключ `protected: false`
+     * поэтому тоже переобъявление — им наследник возвращает вход.
+     *
+     * Новое описание, исходные не меняются: родительское делят все наследники.
+     * Умолчание не переносится — его пересчитывает `rebase` от итогового класса.
+     */
+    inheritFrom(base: TPropSpec): TPropSpec;
+    /** То же описание с заданным умолчанием: опция `with()` плагина идёт впереди умолчания класса. */
+    withDefault(value: unknown): TPropSpec;
+}

package/dist/protected/define/prop-spec.class.js

@@ -0,0 +1,79 @@
+//#region protected/define/prop-spec.class.ts
+/** Составное значение пересекает границу снимком: свой `valueOf()` даёт новый простой объект. */
+function snapshotOf(value) {
+	if (typeof value !== "object" || value === null) return value;
+	return value.valueOf === Object.prototype.valueOf ? value : value.valueOf();
+}
+var TPropSpec = class TPropSpec {
+	name;
+	triggers;
+	_definition;
+	type;
+	protected;
+	/**
+	* @param _definition объявление из contribution: из него берутся `get` и `set`
+	* @param defaults умолчания класса владельца; нет ключа с именем пропа — нет и умолчания
+	*/
+	constructor(name, triggers, _definition, defaults) {
+		this.name = name;
+		this.triggers = triggers;
+		this._definition = _definition;
+		this.type = _definition.type;
+		this.protected = !!_definition.protected;
+		if (defaults && Object.hasOwn(defaults, name.name)) this.default = defaults[name.name];
+		Object.freeze(this);
+	}
+	get hasDefault() {
+		return Object.hasOwn(this, "default");
+	}
+	/** Ключ наследования — полное имя: по нему свойство находят и во фреймворке, и в ядре. */
+	get key() {
+		return this.name.getName();
+	}
+	/** Свои `get`/`set` объявления — для интроспекции; читать и писать надо через `read`/`assign`. */
+	get get() {
+		return this._definition.get;
+	}
+	get set() {
+		return this._definition.set;
+	}
+	/** Прочитать у владельца: `get` объявления, а без него `owner[name]`; составное — снимком. */
+	read(owner) {
+		const { get } = this._definition;
+		return snapshotOf(get ? get(owner) : Reflect.get(owner, this.name.name));
+	}
+	/** Записать владельцу: `set` объявления, а без него сеттер `owner[name]`. */
+	assign(owner, value) {
+		const { set } = this._definition;
+		if (set) set(owner, value);
+		else Reflect.set(owner, this.name.name, value);
+	}
+	/** То же описание с умолчанием от другого класса: наследник пересчитывает, а не копирует. */
+	rebase(defaults) {
+		return new TPropSpec(this.name, this.triggers, this._definition, defaults);
+	}
+	/**
+	* Своё описание поверх одноимённого родительского: переобъявлены ровно те
+	* факты, которые автор написал, остальные — родительские.
+	*
+	* Значим ключ объявления, а не значение, как у умолчания: `protected: true`
+	* у элемента коллекции снимает вход, а `type` и `triggers` остаются
+	* объявленными один раз, у того, кто проп завёл. Ключ `protected: false`
+	* поэтому тоже переобъявление — им наследник возвращает вход.
+	*
+	* Новое описание, исходные не меняются: родительское делят все наследники.
+	* Умолчание не переносится — его пересчитывает `rebase` от итогового класса.
+	*/
+	inheritFrom(base) {
+		return new TPropSpec(this.name, Object.hasOwn(this._definition, "triggers") ? this.triggers : base.triggers, {
+			...base._definition,
+			...this._definition
+		});
+	}
+	/** То же описание с заданным умолчанием: опция `with()` плагина идёт впереди умолчания класса. */
+	withDefault(value) {
+		return new TPropSpec(this.name, this.triggers, this._definition, { [this.name.name]: value });
+	}
+};
+//#endregion
+export { TPropSpec };

package/dist/protected/define/prop-type.d.ts

@@ -0,0 +1,12 @@
+/**
+ * defineType — значение scope слота: конструктор для рантайма, `T` — тип данных слота.
+ *
+ *   default: { scope: { text: defineType<string>(String) } }
+ *
+ * Из `T` выводится scope слота (`DescriptorSlots`), значение без него не
+ * компилируется. У пропа второй записи типа нет: тип значения даёт интерфейс
+ * пропсов ядра (`TProps` класса `ctor`), а `type` в contribution — голый
+ * конструктор для рантайма (`type: String`).
+ */
+import type { TPropType } from './types';
+export declare function defineType<T>(ctor: unknown): TPropType<T>;

package/dist/protected/define/prop-type.js

@@ -0,0 +1,6 @@
+//#region protected/define/prop-type.ts
+function defineType(ctor) {
+	return { ctor };
+}
+//#endregion
+export { defineType };

package/dist/protected/define/slot-declaration.class.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TSlotDeclaration — объявление слота: имя, scope и строка документации.
+ *
+ * Третья категория контракта рядом с пропсами и событиями: имя вынесено из
+ * ключа словаря `slots`, как у пропа. В отличие от пропа и плагина, слот не
+ * наследуется: он описывает разметку компонента, а не экземпляр ядра, и
+ * дескриптор держит только свои слоты (`TComponentDescriptor`). Поэтому
+ * контракта наследования (`IDeclaration`) у слота нет — класть его поверх
+ * родительского некуда.
+ *
+ * Неизменяемо и заморожено: объявление строится один раз на тип, и его делят
+ * все монтирования.
+ */
+import type { ISlotDeclaration } from './contribution.types';
+export declare class TSlotDeclaration implements ISlotDeclaration {
+    readonly name: string;
+    readonly scope?: Record<string, unknown> | undefined;
+    readonly description?: string | undefined;
+    constructor(name: string, scope?: Record<string, unknown> | undefined, description?: string | undefined);
+}

package/dist/protected/define/slot-declaration.class.js

@@ -0,0 +1,14 @@
+//#region protected/define/slot-declaration.class.ts
+var TSlotDeclaration = class {
+	name;
+	scope;
+	description;
+	constructor(name, scope, description) {
+		this.name = name;
+		this.scope = scope;
+		this.description = description;
+		Object.freeze(this);
+	}
+};
+//#endregion
+export { TSlotDeclaration };

package/dist/protected/define/types.d.ts

@@ -0,0 +1,235 @@
+/**
+ * Контракт дескриптора компонента и определения плагина.
+ *
+ * Дескриптор отдаёт декларации: props, events, slots и состав плагинов
+ * библиотеки. Собирает по ним компонент сборка (`assemble/`).
+ *
+ * Типы едут одним параметром — контрактом (`IComponentContract`,
+ * `IPluginContract`): что адаптеру нужно знать о компоненте в типах, лежит в
+ * нём по ключам. Новый факт — новый ключ, сигнатуры функций над дескриптором
+ * при этом не меняются.
+ */
+import type { IContribution, IPropDefinition, ISlotDefinition } from './contribution.types';
+import type { TName } from './name.class';
+import type { TPropSpec } from './prop-spec.class';
+import type { TSlotDeclaration } from './slot-declaration.class';
+import type { IPluginConstructor } from '@soxa-ui/plugins';
+/**
+ * Конструктор инстанса компонента.
+ *
+ * Параметры стёрты: пропсы и опции приходят от фреймворка в рантайме, и сверять
+ * их здесь не с чем. Тип инстанса не стёрт — его дескриптор несёт дальше, в
+ * контракте (см. AGENTS.md, «`any`: где он честный»), и из него же выводятся
+ * типы пропсов и событий (`TInstanceProps`, `TInstanceEvents`).
+ *
+ * `defaultValues` — статика класса ядра (`TComponentView.defaultValues`): из неё
+ * `defineComponent` собирает умолчания пропов в декларации. Объявлена в типе,
+ * чтобы читать её без рефлексии; у класса без статики её просто нет.
+ */
+export type TComponentCtor<TInstance extends object = object> = (new (...args: any[]) => TInstance) & {
+    readonly defaultValues?: Readonly<Record<string, unknown>>;
+};
+/** Класс плагина. Параметры стёрты по той же причине, что у `TComponentCtor`. */
+export type TPluginCtor = IPluginConstructor<any, any, any>;
+/**
+ * Объявление, которое наследуется: проп и определение плагина.
+ *
+ * Наследование у обоих одно: своё объявление ложится на одноимённое
+ * родительское и остаётся на его месте (`inheritDeclarations`). Различается
+ * только смысл слова «поверх», и знает его само объявление, а не тот, кто
+ * складывает списки: проп переобъявляет написанные факты
+ * (`TPropSpec.inheritFrom`), плагин встаёт целиком — опции задаёт место
+ * установки.
+ *
+ * Поэтому у дескриптора нет ни ветки на категорию, ни функции извлечения
+ * ключа: новая категория объявлений приносит своё правило с собой. Слот
+ * такого контракта не имеет: он описывает разметку, а она не наследуется
+ * (`TComponentDescriptor`).
+ */
+export interface IDeclaration<T> {
+    /** Одно объявление на ключ: полное имя пропа, класс плагина. */
+    readonly key: unknown;
+    /** Своё поверх родительского. Результат — новое объявление; оба исходных не меняются. */
+    inheritFrom(base: T): T;
+}
+/**
+ * Что плагины добавляют компоненту в типах, уже под именами с неймспейсом:
+ * `aria_label`, `element:ready`, `layout_styles`. У одного плагина это часть
+ * его контракта, у компонента — сумма по всем плагинам дескриптора.
+ */
+export interface IPluginsContract {
+    /** Входы — незащищённые пропсы, их пишет потребитель. */
+    props: object;
+    /**
+     * Explicitly declared public plugin events.
+     */
+    events: object;
+    /** Выходы — защищённые пропсы: их вычисляет плагин, разметка только читает. */
+    outputs: object;
+}
+/**
+ * Контракт плагина в типах. Выводит его `definePlugin` из класса плагина и его
+ * contribution; руками контракт не пишут.
+ */
+export interface IPluginContract extends IPluginsContract {
+    /** Опции установки — второй параметр `install()` класса плагина. */
+    options: object;
+}
+/**
+ * Определение плагина: его контракт и, в составе дескриптора, опции установки.
+ *
+ * Контракт — свойство класса плагина, и объявляют его один раз, константой.
+ * Опции — свойство места, где плагин поставили: дескриптор берёт определение
+ * как есть или с опциями — `DismissPluginDescriptor.with({ focusOutside: true })`.
+ */
+export interface IPluginDefinition<C extends IPluginContract = IPluginContract> extends IDeclaration<IPluginDefinition<C>> {
+    /** Фантомное поле: в рантайме его нет, оно только несёт контракт в типе. */
+    readonly __contract?: C;
+    readonly ctor: TPluginCtor;
+    /** Ключ наследования — класс плагина: дважды один класс компоненту не ставят. */
+    readonly key: TPluginCtor;
+    /** Нормализованные props из contribution, с умолчаниями. */
+    readonly props: readonly TPropSpec[];
+    /** Нормализованные events из contribution */
+    readonly events: readonly TName[];
+    /** Опции, передаваемые в plugin.install(ctx, options) */
+    readonly options?: object;
+    /** Namespace плагина. */
+    readonly namespace?: string;
+    /** Те же пропсы и события — в форме, общей с дескриптором: по ней строится поверхность. */
+    getProps(): readonly TPropSpec[];
+    getEvents(): readonly TName[];
+    /**
+     * То же определение с опциями установки. Исходное не меняется: его делят
+     * все дескрипторы, которые плагин ставят. Умолчания пропсов пересчитываются —
+     * заданная опция идёт впереди `defaultValues` класса.
+     */
+    with(options: C['options']): IPluginDefinition<C>;
+}
+/**
+ * Объявление слота в опциях `defineComponent`.
+ *
+ * Уже `ISlotDefinition` аксессора: там scope — любой словарь, рантайму нужен
+ * только состав ключей. Здесь значение scope — `defineType<T>`, и из него
+ * выводится тип данных слота (`DescriptorSlots`). Значение без типа (`String`)
+ * поэтому не компилируется, а не превращается в `unknown` в типах адаптеров.
+ */
+export interface IComponentSlotDefinition extends ISlotDefinition {
+    readonly scope?: Readonly<Record<string, TPropType<unknown>>>;
+}
+/** Слоты в опциях `defineComponent`: имя слота — ключ словаря, как у `slots` в `IContribution`. */
+export type TSlotDefinitions = Readonly<Record<string, IComponentSlotDefinition>>;
+/**
+ * Property triggers refresh state and models; they do not publish component events.
+ * Each trigger must name an event from the instance event map.
+ */
+export interface IComponentPropDefinition<TEventName extends string = string> extends IPropDefinition {
+    readonly triggers?: readonly TEventName[];
+}
+/** Contribution компонента: то же, что `IContribution`, но у слотов scope с типами. */
+export interface IComponentContribution extends IContribution {
+    readonly props?: Readonly<Record<string, IComponentPropDefinition>>;
+    readonly slots?: TSlotDefinitions;
+}
+/**
+ * Component options infer the instance from `ctor` or `extends`, public event names
+ * from explicit `events`, own slots from `slots`, and plugin contracts from `plugins`.
+ */
+export interface IComponentOptions {
+    /** Конструктор core-компонента. Без него инстанс наследуется от `extends`. */
+    readonly ctor?: TComponentCtor;
+    /** Родительский дескриптор: наследуются props, events и plugins, слоты — нет */
+    readonly extends?: IComponentDescriptor;
+    /** Собственная контрибуция компонента */
+    readonly contribution?: IComponentContribution;
+    /** Плагины (каждый — результат definePlugin) */
+    readonly plugins?: readonly IPluginDefinition[];
+}
+/** Контекст сборки набора: что знает о компоненте тот, кто его собирает. */
+export interface IBundleContext {
+    /** Имя места во вложенной разметке; нет — компонент поставил пользователь. */
+    embedded?: string;
+}
+/**
+ * Контракт компонента в типах — всё, что адаптер выводит из дескриптора.
+ *
+ * Здесь только то, чего не вывести из остального: пропсы и карта событий —
+ * свойства инстанса (`TInstanceProps`, `TInstanceEvents`), поэтому отдельных
+ * ключей у них нет. Руками контракт не пишут: его выводит `defineComponent`.
+ */
+export interface IComponentContract {
+    /** Инстанс, который строит `ctor`. */
+    instance: object;
+    /**
+     * Explicit event names declared here or inherited through `extends`.
+     * They narrow the instance event map, including declarations without their own class.
+     */
+    eventName: string;
+    /**
+     * Имена защищённых пропсов — свои поверх `extends`, как и в рантайме:
+     * наследник переобъявляет унаследованный проп в обе стороны, поэтому
+     * `protected: true` имя сюда добавляет, а объявление без него — убирает.
+     * Из пропсов компонента эти имена вычитаются (`DescriptorProps`): значение
+     * вычисляет владелец, входа у разметки нет.
+     */
+    protectedName: string;
+    /** Слоты, имя → scope: только свои, слоты `extends` сюда не входят. */
+    slots: object;
+    /** Сумма контрактов плагинов — своих и `extends`. */
+    plugins: IPluginsContract;
+}
+/**
+ * Дескриптор компонента — единственный источник истины.
+ *
+ * Контракт `C` — фантом: в рантайме его нет, но из него адаптеры выводят типы
+ * прямо из фабрики дескриптора (`DescriptorAllProps<typeof ButtonDescriptor>`
+ * → `IButtonProps & { aria_label?: … }`).
+ */
+export interface IComponentDescriptor<C extends IComponentContract = IComponentContract> {
+    /** Фантомное поле: в рантайме его нет, оно только несёт контракт в типе. */
+    readonly __contract?: C;
+    readonly ctor: TComponentCtor<C['instance']>;
+    /** Own component props (excluding plugin props). */
+    readonly props: readonly TPropSpec[];
+    /** Own component events (excluding plugin events). */
+    readonly events: readonly TName[];
+    /**
+     * Слоты — только свои: они описывают разметку, а она не наследуется (см.
+     * `TComponentDescriptor`). Плагины слотов не имеют, поэтому отдельного
+     * «полного» списка, как у пропсов и событий, у слотов нет.
+     */
+    readonly slots: readonly TSlotDeclaration[];
+    readonly plugins: readonly IPluginDefinition[];
+    /** All props: own + all plugin props (flat). */
+    getProps(): readonly TPropSpec[];
+    /** All events: own + all plugin events (flat). */
+    getEvents(): readonly TName[];
+}
+/**
+ * Значение scope слота: конструктор для рантайма и фантомный `T` — тип данных,
+ * которые получает слот (из него `DescriptorSlots` выводит scope). Собирает его
+ * `defineType`.
+ *
+ * Имя осталось от пропсов, но у пропа такой записи нет: тип его значения даёт
+ * интерфейс пропсов ядра, а `type` декларации — голый конструктор.
+ */
+export type TPropType<T> = {
+    /**
+     * Фантомное поле: в рантайме его нет, оно только несёт `T` в типе.
+     * Необязательное, поэтому `defineType` собирает значение без приведения.
+     */
+    readonly __type?: T;
+    /** JS-конструктор значения: `String`, `Object`, … Рантайму слота нужны лишь ключи scope. */
+    readonly ctor: unknown;
+};
+/**
+ * Scope слота, который ничего не передаёт внутрь.
+ *
+ * Именно `object`, а не `Record<string, never>`: адаптеры отличают слот без
+ * scope по `keyof S extends never` (см. TSnippetSlots в ui/svelte). У
+ * `Record<string, never>` есть индексная сигнатура, поэтому его `keyof` —
+ * это `string`, и проверка ломается: сниппет начинает требовать аргумент.
+ * У `object` же `keyof` пуст, как и у прежнего `{}`, но без его дыры,
+ * пропускавшей `0` и `""`.
+ */
+export type TEmptySlotScope = object;

package/dist/protected/index.d.ts

@@ -0,0 +1,4 @@
+export * from './define';
+export * from './naming';
+export * from './registry';
+export * from './adapter';

package/dist/protected/naming/common-profile.d.ts

@@ -0,0 +1,10 @@
+/**
+ * CommonProfile — общий формат имён, не принадлежащий ни одному фреймворку.
+ *
+ * Им говорит всё, что устроено одинаково во всех адаптерах: ключи мешка
+ * `pluginProps` (`timer_ms`), имя в конверте `plugin:event` (`timer:tick`) и
+ * начальные значения при сборке — имя пропа во всех фреймворках одно, поэтому
+ * сборке профиль адаптера не нужен.
+ */
+import type { IAdapterProfile } from './strategy.types';
+export declare const CommonProfile: IAdapterProfile;

package/dist/protected/naming/common-profile.js

@@ -0,0 +1,16 @@
+import { underscorePropNaming } from "./naming.js";
+//#region protected/naming/common-profile.ts
+/**
+* CommonProfile — общий формат имён, не принадлежащий ни одному фреймворку.
+*
+* Им говорит всё, что устроено одинаково во всех адаптерах: ключи мешка
+* `pluginProps` (`timer_ms`), имя в конверте `plugin:event` (`timer:tick`) и
+* начальные значения при сборке — имя пропа во всех фреймворках одно, поэтому
+* сборке профиль адаптера не нужен.
+*/
+var CommonProfile = { naming: {
+	prop: underscorePropNaming,
+	event: (name) => name.getName()
+} };
+//#endregion
+export { CommonProfile };

package/dist/protected/naming/index.d.ts

@@ -0,0 +1,4 @@
+export { CommonProfile } from './common-profile';
+export { underscorePropNaming, callbackEventNaming, PLUGIN_PROPS } from './naming';
+export type { TCallbackEventName, TCallbackEventProps, TUnderscorePropName } from './naming.types';
+export type { IAdapterProfile, INamingStrategy } from './strategy.types';

package/dist/protected/naming/naming.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Общая часть стратегий именования, одинаковая во всех фреймворках.
+ *
+ * Различается только `event`: Vue сохраняет двоеточие (`element:ready`),
+ * React делает колбэк-проп (`onElementReady`), Angular — camelCase-аутпут с
+ * префиксом `so` (`soElementReady`), Web Components — имя ядра с префиксом
+ * `so:` (`so:element:ready`). Имя пропа же везде одно и то же, потому что
+ * публичный API компонентов должен читаться одинаково на всех фреймворках.
+ */
+import type { TName } from '../define/name.class';
+/**
+ * `styles` @ ns `icon-styles` → `iconStyles_styles`; без namespace — как есть.
+ *
+ * Двоеточие в имени пропа недопустимо (это не валидный JS-идентификатор
+ * и не биндится в шаблонах), поэтому namespace склеивается через `_`.
+ */
+export declare function underscorePropNaming(name: TName): string;
+/**
+ * `element:ready` → `onElementReady`.
+ *
+ * Общая стратегия для фреймворков, где события — это колбэк-пропы: React,
+ * Svelte 5 и Solid. Колбэк строится из `TName.getName()`: своей копии формата
+ * `namespace:name` здесь нет. Тип-зеркало живёт в naming.types.ts и обязано
+ * меняться синхронно.
+ */
+export declare function callbackEventNaming(name: TName): string;
+/**
+ * Проп со значениями для пропсов плагинов, поставленных снаружи:
+ * `{ timer_ms: 500 }`. Один на все компоненты и одинаковый во всех адаптерах —
+ * статический слой Vue, Angular и Web Components объявляет его заранее, а
+ * пропсы внешнего плагина узнаются только в рантайме.
+ */
+export declare const PLUGIN_PROPS = "pluginProps";

package/dist/protected/naming/naming.js

@@ -0,0 +1,34 @@
+//#region protected/naming/naming.ts
+/**
+* `styles` @ ns `icon-styles` → `iconStyles_styles`; без namespace — как есть.
+*
+* Двоеточие в имени пропа недопустимо (это не валидный JS-идентификатор
+* и не биндится в шаблонах), поэтому namespace склеивается через `_`.
+*/
+function underscorePropNaming(name) {
+	if (!name.namespace) return name.name;
+	return `${name.namespace.replace(/-(\w)/g, (_, char) => char.toUpperCase())}_${name.name}`;
+}
+function toPascalCase(input) {
+	return input.split(/[-:]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* `element:ready` → `onElementReady`.
+*
+* Общая стратегия для фреймворков, где события — это колбэк-пропы: React,
+* Svelte 5 и Solid. Колбэк строится из `TName.getName()`: своей копии формата
+* `namespace:name` здесь нет. Тип-зеркало живёт в naming.types.ts и обязано
+* меняться синхронно.
+*/
+function callbackEventNaming(name) {
+	return `on${toPascalCase(name.getName())}`;
+}
+/**
+* Проп со значениями для пропсов плагинов, поставленных снаружи:
+* `{ timer_ms: 500 }`. Один на все компоненты и одинаковый во всех адаптерах —
+* статический слой Vue, Angular и Web Components объявляет его заранее, а
+* пропсы внешнего плагина узнаются только в рантайме.
+*/
+var PLUGIN_PROPS = "pluginProps";
+//#endregion
+export { PLUGIN_PROPS, callbackEventNaming, underscorePropNaming };

package/dist/protected/naming/naming.types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Тип-зеркало стратегии именования событий из naming.ts (`callbackEventNaming`).
+ *
+ * TypeScript не умеет применять рантайм-функции на уровне типов, поэтому логика
+ * продублирована условными типами. Оба определения обязаны меняться СИНХРОННО.
+ *
+ * Благодаря этому событийные пропы компонентов выводятся автоматически из
+ * дескрипторов, без ручного перечисления:
+ *
+ *   TCallbackEventProps<DescriptorAllEvents<typeof ComponentViewDescriptor>>
+ *     → { onShow?, onChangeVisible?, onElementReady?, ... }
+ *
+ * Используется React-, Svelte- и Solid-адаптерами: во всех трёх события —
+ * колбэк-пропы.
+ */
+/** Split<'show:before', '-' | ':'> → ['show', 'before'] */
+type Split<S extends string, D extends string> = S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
+/** Join<['Show', 'Before'], ''> → 'ShowBefore' */
+type Join<P extends string[], Sep extends string> = P extends [
+    infer F extends string,
+    ...infer R extends string[]
+] ? R extends [] ? F : `${F}${Sep}${Join<R, Sep>}` : '';
+/** CapitalizeAll<['show', 'before']> → ['Show', 'Before'] */
+type CapitalizeAll<T extends string[]> = T extends [
+    infer F extends string,
+    ...infer R extends string[]
+] ? [Capitalize<F>, ...CapitalizeAll<R>] : [];
+/** ToPascalCase<'show:before'> → 'ShowBefore' */
+type ToPascalCase<S extends string> = Join<CapitalizeAll<Split<S, '-' | ':'>>, ''>;
+/** TCallbackEventName<'show:before'> → 'onShowBefore' */
+export type TCallbackEventName<T extends string> = `on${ToPascalCase<T>}`;
+/** TCallbackEventProps<DescriptorAllEvents<...>> → { onShow?: ..., onChangeVisible?: ... } */
+export type TCallbackEventProps<T extends object> = {
+    [K in keyof T as K extends string ? TCallbackEventName<K> : never]?: T[K];
+};
+/**
+ * Тип-зеркало стратегии именования пропов из naming.ts (`underscorePropNaming`).
+ *
+ * Как и выше, TypeScript не умеет применять рантайм-функцию на уровне типов —
+ * логика продублирована. Оба определения обязаны меняться СИНХРОННО.
+ *
+ * Используется `DescriptorAllProps` в `packages/setup/protected/define/inference.types.ts`
+ * для вывода пропов плагинов из их `namespace` (`aria` + `label` → `aria_label`).
+ */
+/** CamelCaseNamespace<'input-bool'> → 'inputBool' */
+type CamelCaseNamespace<S extends string> = S extends `${infer Head}-${infer Rest}` ? `${Head}${CamelCaseNamespace<Capitalize<Rest>>}` : S;
+/** TUnderscorePropName<'aria', 'label'> → 'aria_label'; TUnderscorePropName<undefined, 'text'> → 'text' */
+export type TUnderscorePropName<N extends string | undefined, K extends string> = N extends string ? `${CamelCaseNamespace<N>}_${K}` : K;
+export {};