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

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

@@ -0,0 +1,20 @@
+/**
+ * normalizeContribution — contribution в описания: пропсы (`TPropSpec`), события (`TName`) и слоты.
+ *
+ * Неймспейс применяется к каждому имени пропа, триггера и события. Слоты
+ * неймспейса не получают: они принадлежат компоненту, а у плагинов слотов нет
+ * вовсе — плагин не рендерит.
+ *
+ * Умолчаний у описаний здесь ещё нет: умолчание принадлежит классу владельца, и
+ * приставляет его тот, кто класс знает, — дескриптор (`TPropSpec.rebase`) или
+ * определение плагина.
+ */
+import type { IContribution } from './contribution.types';
+import { TName } from './name.class';
+import { TPropSpec } from './prop-spec.class';
+import { TSlotDeclaration } from './slot-declaration.class';
+export declare function normalizeContribution(contribution?: IContribution, namespace?: string): {
+    props: TPropSpec[];
+    events: TName[];
+    slots: TSlotDeclaration[];
+};

package/dist/protected/define/contribution.js

@@ -0,0 +1,18 @@
+import { TName } from "./name.class.js";
+import { TPropSpec } from "./prop-spec.class.js";
+import { TSlotDeclaration } from "./slot-declaration.class.js";
+//#region protected/define/contribution.ts
+function normalizeContribution(contribution, namespace) {
+	if (!contribution) return {
+		props: [],
+		events: [],
+		slots: []
+	};
+	return {
+		props: Object.entries(contribution.props ?? {}).map(([name, definition]) => new TPropSpec(new TName(name, namespace), Object.freeze((definition.triggers ?? []).map((trigger) => new TName(trigger, namespace))), definition)),
+		events: (contribution.events ?? []).map((event) => new TName(event, namespace)),
+		slots: Object.entries(contribution.slots ?? {}).map(([name, definition]) => new TSlotDeclaration(name, definition.scope, definition.description))
+	};
+}
+//#endregion
+export { normalizeContribution };

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

@@ -0,0 +1,66 @@
+/**
+ * Синтаксис объявления в дескрипторе: пропсы, события и слоты — то, что автор пишет в `contribution`.
+ *
+ * Это вход описания. Во что он превращается — `TPropSpec`, `TName` и
+ * `ISlotDeclaration` — решает `normalizeContribution`.
+ */
+/**
+ * Объявление одного свойства. Ключ словаря `props` — имя свойства.
+ *
+ * `get`/`set` объявлены методами, а не свойствами-функциями: contribution пишет
+ * их под своего владельца — инстанс компонента или плагин (у `AnchorPluginDescriptor`
+ * это `set: (plugin: TAnchorPlugin, value: Element | null) => …`), а слой вызывает
+ * их с владельцем того же участника — эту связь держит дескриптор, а не тип. Метод
+ * принимает такую реализацию без приведения.
+ */
+export interface IPropDefinition {
+    type?: unknown;
+    /** Свойство вычисляет владелец, снаружи его только читают. */
+    protected?: boolean;
+    /**
+     * Owner events that refresh this property and its model binding.
+     * Triggers do not publish public component or plugin events.
+     */
+    triggers?: readonly string[];
+    /** Нетривиальное чтение: вместо `owner[name]`. */
+    get?(instance: object): unknown;
+    /** Нетривиальная запись: вместо `owner[name] = value`. */
+    set?(instance: object, value: unknown): void;
+}
+/**
+ * Объявление одного слота. Ключ словаря `slots` — имя слота.
+ *
+ * Слоты — третья категория контракта рядом с пропсами и событиями. Синтаксис у
+ * каждого фреймворка свой (`<template #leading>`, `{#snippet}`, проп с JSX,
+ * `<ng-template>`, атрибут `slot`) — общими остаются имена, состав и scope.
+ */
+export interface ISlotDefinition {
+    /**
+     * Данные, которые компонент передаёт ВНУТРЬ слота (scoped slot):
+     * `v-slot="{ text }"`, `{#snippet children(scope)}`, `let-text`.
+     *
+     * **Это не тип содержимого и не ограничение на него.** В слот можно положить
+     * что угодно. Значения несут тип данных слота (`defineType<T>`): в рантайме
+     * нужен лишь состав ключей, тип живёт на уровне типов.
+     */
+    scope?: Record<string, unknown>;
+    /** Одна строка для документации и генерации. */
+    description?: string;
+}
+/** Нормализованное объявление слота: имя вынесено из ключа словаря. */
+export interface ISlotDeclaration {
+    readonly name: string;
+    readonly scope?: Record<string, unknown>;
+    readonly description?: string;
+}
+/**
+ * Contribution: словарь пропсов (имя → объявление), события сырыми строками и слоты.
+ *
+ * Только для чтения, как и `IPropDefinition.triggers`: объявление после записи
+ * не меняется, а его литеральный тип — источник типов дескриптора.
+ */
+export interface IContribution {
+    readonly props?: Readonly<Record<string, IPropDefinition>>;
+    readonly events?: readonly string[];
+    readonly slots?: Readonly<Record<string, ISlotDefinition>>;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * defineDescriptor — дескриптор компонента строится один раз, а не на каждое монтирование.
+ *
+ * Фабрика дескриптора ленива намеренно: дескрипторы ссылаются друг на друга
+ * через `extends`, и у коллекций эти ссылки образуют цикл, который на уровне
+ * модулей не развязать. Но результат от вызова к вызову один и тот же:
+ * декларации собираются из contribution и родителя, умолчания — из статики
+ * класса ядра, и ничего из этого после сборки не меняется.
+ *
+ *   export const ButtonDescriptor = defineDescriptor(() =>
+ *     defineComponent({ ctor: TButton, extends: TextableDescriptor(), … }),
+ *   )
+ *
+ * До этого `ButtonDescriptor()` на каждом монтировании пересобирал всю цепочку
+ * до `EntityDescriptor`, а адаптеры зовут фабрику дважды: при импорте модуля
+ * компонента (статические пропсы и события) и в `setup` на каждое монтирование.
+ * Теперь оба вызова получают один объект, и у дескриптора появляется
+ * устойчивая идентичность — по ней кэшируются состав и его публичная
+ * поверхность.
+ */
+export declare function defineDescriptor<T extends object>(build: () => T): () => T;

package/dist/protected/define/descriptor.js

@@ -0,0 +1,27 @@
+//#region protected/define/descriptor.ts
+/**
+* defineDescriptor — дескриптор компонента строится один раз, а не на каждое монтирование.
+*
+* Фабрика дескриптора ленива намеренно: дескрипторы ссылаются друг на друга
+* через `extends`, и у коллекций эти ссылки образуют цикл, который на уровне
+* модулей не развязать. Но результат от вызова к вызову один и тот же:
+* декларации собираются из contribution и родителя, умолчания — из статики
+* класса ядра, и ничего из этого после сборки не меняется.
+*
+*   export const ButtonDescriptor = defineDescriptor(() =>
+*     defineComponent({ ctor: TButton, extends: TextableDescriptor(), … }),
+*   )
+*
+* До этого `ButtonDescriptor()` на каждом монтировании пересобирал всю цепочку
+* до `EntityDescriptor`, а адаптеры зовут фабрику дважды: при импорте модуля
+* компонента (статические пропсы и события) и в `setup` на каждое монтирование.
+* Теперь оба вызова получают один объект, и у дескриптора появляется
+* устойчивая идентичность — по ней кэшируются состав и его публичная
+* поверхность.
+*/
+function defineDescriptor(build) {
+	let descriptor;
+	return () => descriptor ??= build();
+}
+//#endregion
+export { defineDescriptor };

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

@@ -0,0 +1,11 @@
+export { normalizeContribution } from './contribution';
+export { definePlugin, pluginContractOf } from './plugin';
+export { defineComponent } from './component';
+export { defineDescriptor } from './descriptor';
+export { defineType } from './prop-type';
+export { TName } from './name.class';
+export { TPropSpec } from './prop-spec.class';
+export { TSlotDeclaration } from './slot-declaration.class';
+export type { IContribution, IPropDefinition, ISlotDeclaration, ISlotDefinition, } from './contribution.types';
+export type { IBundleContext, IComponentContract, IComponentContribution, IComponentDescriptor, IComponentOptions, IComponentPropDefinition, IComponentSlotDefinition, IDeclaration, IPluginContract, IPluginDefinition, IPluginsContract, TComponentCtor, TEmptySlotScope, TPluginCtor, TPropType, TSlotDefinitions, } from './types';
+export type { DescriptorAllEvents, DescriptorAllProps, DescriptorEvents, DescriptorInstance, DescriptorPluginOutputs, DescriptorPluginProps, DescriptorProps, DescriptorSlots, TContractOf, TInstanceEvents, } from './inference.types';

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

@@ -0,0 +1,247 @@
+/**
+ * Вывод типов: контракт плагина и компонента из их объявлений и типы для адаптеров из контракта.
+ *
+ * Фабрика дескриптора — единственный источник типов: адаптер не импортирует
+ * интерфейсы пропсов и карты событий из ядра, а выводит их отсюда. Сам
+ * дескриптор их тоже не повторяет: `defineComponent` берёт пропсы у класса
+ * ядра (`ctor`), события — из его карты, суженной до имён, которые дескриптор
+ * публикует, а слоты — из их объявления. У плагина так же: `definePlugin`
+ * берёт типы пропсов и карту событий у класса плагина, а состав — у
+ * contribution.
+ */
+import type { IEntity, TEvented } from '@soxa-ui/core';
+import type { TPluginInternalEvents } from '@soxa-ui/plugins';
+import type { TUnderscorePropName } from '../naming';
+import type { IComponentDescriptor, IPluginDefinition, IPluginsContract, TEmptySlotScope, TPropType } from './types';
+/**
+ * Пропсы инстанса — параметр `TProps` его сущности ядра (`IEntity<TProps>`):
+ * интерфейс, который класс принимает конструктором и отдаёт `getProps()`.
+ * Класс не из ядра — словарь без типа, как у дескриптора без `ctor` и `extends`.
+ *
+ * У дженерик-класса на месте параметра стоит его констрейнт, а не дефолт, как
+ * и у самого инстанса: `IValueControlProps<unknown>` у `TValueControl`.
+ */
+type TInstanceProps<TInstance> = TInstance extends IEntity<infer P extends object> ? P : Record<string, unknown>;
+/** События инстанса — карта его шины (`events: TEvented<TEvents>`); шины нет — событий нет. */
+export type TInstanceEvents<TInstance> = TInstance extends {
+    readonly events: TEvented<infer E>;
+} ? E : object;
+/**
+ * Имя, которое дескриптор может объявить в `events` и `triggers`, — ключ карты
+ * событий инстанса. Шины нет (`EntityDescriptor` и `CollectionDescriptor` без
+ * класса ядра) — сверять не с чем, и имя любое: карту даст наследник.
+ */
+type TInstanceEventName<TInstance> = TInstance extends {
+    readonly events: TEvented<infer E>;
+} ? Extract<keyof E, string> : string;
+/** The instance event map narrowed to explicit declarations, including inherited events. */
+type TPublishedEvents<TInstance, TName extends string> = TInstance extends {
+    readonly events: TEvented<infer E>;
+} ? Pick<E, Extract<TName, keyof E>> : object;
+/** Словарь `props` объявления; нет — пустой. */
+type TDeclaredProps<TContribution> = TContribution extends {
+    readonly props: infer P extends object;
+} ? P : object;
+/** Only the explicit event list contributes to the public event contract. */
+type TDeclaredEventName<TContribution> = TContribution extends {
+    readonly events: readonly (infer E extends string)[];
+} ? E : never;
+/**
+ * Имена, объявленные защищёнными: у плагина это его выходы, у компонента —
+ * то, что из пропсов уходит (`protected` значит «значение вычисляет владелец,
+ * разметка только читает»).
+ */
+type TProtectedKey<TProps> = Extract<{
+    [K in keyof TProps]: TProps[K] extends {
+        readonly protected: true;
+    } ? K : never;
+}[keyof TProps], string>;
+/**
+ * Имена, объявленные входами: ключ в объявлении есть, а `protected: true` в
+ * нём нет. Переобъявление наследника ходит в обе стороны, поэтому у
+ * защищённого пропа родителя такое имя возвращает вход.
+ */
+type TInputKey<TProps> = Extract<Exclude<keyof TProps, TProtectedKey<TProps>>, string>;
+/**
+ * Тип значения пропа плагина: что отдаёт его `get`, а без него — одноимённое
+ * свойство класса. Ни того ни другого — типа нет.
+ */
+type TPluginPropValue<TInstance, TDefinition, K> = TDefinition extends {
+    get(instance: never): infer TValue;
+} ? TValue : K extends keyof TInstance ? TInstance[K] : unknown;
+/** `{ label }` @ `aria` → `{ aria_label }` (naming — как в `underscorePropNaming`). */
+type TNamespacedProps<T, N extends string | undefined> = {
+    [K in keyof T as K extends string ? TUnderscorePropName<N, K> : never]: T[K];
+};
+/** `{ ready }` @ `element` → `{ 'element:ready' }` (формат — как у `TName.getName()`). */
+type TNamespacedEvents<T, N extends string | undefined> = {
+    [K in keyof T as K extends string ? (N extends string ? `${N}:${K}` : K) : never]: T[K];
+};
+/** Plugin lifecycle events stay internal when inferring the public contract. */
+type TPublicPluginEvents<TInstance> = Omit<TInstanceEvents<TInstance>, keyof TPluginInternalEvents>;
+/** Опции установки — второй параметр `install()` класса; не объявлен — любой объект. */
+type TPluginOptions<TInstance> = TInstance extends {
+    install(ctx: never, options?: infer TOptions extends object): void;
+} ? TOptions : object;
+/**
+ * Контракт плагина: состав — из contribution, типы — из класса.
+ *
+ * Входы — незащищённые пропсы, выходы — защищённые, события — карта класса,
+ * суженная до опубликованных имён, как у компонента (`TPublishedEvents`).
+ * Второй записи пропсов и событий рядом с объявлением нет.
+ */
+export type TPluginContractFrom<TInstance, N extends string | undefined, TContribution> = {
+    options: TPluginOptions<TInstance>;
+    props: TNamespacedProps<{
+        -readonly [K in Exclude<keyof TDeclaredProps<TContribution>, TProtectedKey<TDeclaredProps<TContribution>>>]?: TPluginPropValue<TInstance, TDeclaredProps<TContribution>[K], K>;
+    }, N>;
+    events: TNamespacedEvents<Pick<TPublicPluginEvents<TInstance>, Extract<TDeclaredEventName<TContribution>, keyof TPublicPluginEvents<TInstance>>>, N>;
+    outputs: TNamespacedProps<{
+        readonly [K in TProtectedKey<TDeclaredProps<TContribution>>]: TPluginPropValue<TInstance, TDeclaredProps<TContribution>[K], K>;
+    }, N>;
+};
+/**
+ * Что наследник берёт у дескриптора без `extends`: ни инстанса, ни имён, ни
+ * плагинов. Слотов здесь нет — у родителя их не берут (`TContractFrom`).
+ */
+type TRootContract = {
+    instance: object;
+    eventName: never;
+    protectedName: never;
+    plugins: {
+        props: object;
+        events: object;
+        outputs: object;
+    };
+};
+/** Контракт родителя из `extends`; нет — корневой. */
+type TParentContract<TOptions> = TOptions extends {
+    readonly extends: IComponentDescriptor<infer C>;
+} ? C : TRootContract;
+/** Инстанс — из своего `ctor`, а без него родительский. */
+type TOptionsInstance<TOptions> = TOptions extends {
+    readonly ctor: new (...args: any[]) => infer TInstance extends object;
+} ? TInstance : TParentContract<TOptions>['instance'];
+type TOptionsContribution<TOptions> = TOptions extends {
+    readonly contribution: infer C;
+} ? C : object;
+/** Scope слота из объявления: `defineType<T>` даёт `T`, слот без scope — `TEmptySlotScope`. */
+type TSlotScope<TSlot> = TSlot extends {
+    readonly scope: infer TScope extends Readonly<Record<string, TPropType<unknown>>>;
+} ? {
+    -readonly [K in keyof TScope]: TScope[K] extends TPropType<infer T> ? T : never;
+} : TEmptySlotScope;
+/** Слоты из объявления `contribution.slots`: имя слота → его scope; объявления нет — слотов нет. */
+type TDeclaredSlots<TContribution> = TContribution extends {
+    readonly slots: infer S;
+} ? {
+    -readonly [K in keyof S]: TSlotScope<S[K]>;
+} : object;
+/** Объединение → пересечение: сумма частей контрактов всех плагинов списка. */
+type TIntersection<TUnion> = (TUnion extends unknown ? (part: TUnion) => void : never) extends (part: infer TPart) => void ? TPart : never;
+/** Одна часть контракта (`props`, `events`, `outputs`) у всех плагинов списка разом. */
+type TPluginsPart<TPlugin, K extends keyof IPluginsContract> = [TPlugin] extends [never] ? object : TIntersection<TPlugin extends IPluginDefinition<infer C> ? C[K] : never> extends infer TPart extends object ? TPart : object;
+/** Сумма контрактов своих плагинов из `plugins`. */
+type TOptionsPlugins<TOptions> = TOptions extends {
+    readonly plugins: readonly (infer TPlugin)[];
+} ? {
+    props: TPluginsPart<TPlugin, 'props'>;
+    events: TPluginsPart<TPlugin, 'events'>;
+    outputs: TPluginsPart<TPlugin, 'outputs'>;
+} : {
+    props: object;
+    events: object;
+    outputs: object;
+};
+/**
+ * Контракт дескриптора из опций `defineComponent`: своё поверх родительского.
+ *
+ * Слоты — только свои, как и в рантайме (`TComponentDescriptor`): они
+ * описывают разметку, а разметка у наследника своя, и слоты `extends` ей
+ * ничего не обещают.
+ */
+export type TContractFrom<TOptions> = {
+    instance: TOptionsInstance<TOptions>;
+    eventName: TParentContract<TOptions>['eventName'] | TDeclaredEventName<TOptionsContribution<TOptions>>;
+    protectedName: Exclude<TParentContract<TOptions>['protectedName'], TInputKey<TDeclaredProps<TOptionsContribution<TOptions>>>> | TProtectedKey<TDeclaredProps<TOptionsContribution<TOptions>>>;
+    slots: TDeclaredSlots<TOptionsContribution<TOptions>>;
+    plugins: {
+        props: TParentContract<TOptions>['plugins']['props'] & TOptionsPlugins<TOptions>['props'];
+        events: TParentContract<TOptions>['plugins']['events'] & TOptionsPlugins<TOptions>['events'];
+        outputs: TParentContract<TOptions>['plugins']['outputs'] & TOptionsPlugins<TOptions>['outputs'];
+    };
+};
+/**
+ * Сверка имён событий: `events` и триггеры своих пропсов — ключи карты событий
+ * инстанса. Опечатка в триггере или событие, которого класс не шлёт, — ошибка
+ * компиляции дескриптора. Имена родителя приходят из `extends` готовыми: их
+ * сверил родитель, если у него был класс ядра. У родителя без класса
+ * (`EntityDescriptor`, `CollectionDescriptor`) их сверить было не с чем, и
+ * карту к ним прикладывает наследник.
+ */
+export type TCheckedEventNames<TOptions> = {
+    readonly contribution?: {
+        readonly events?: readonly TInstanceEventName<TOptionsInstance<TOptions>>[];
+        readonly props?: {
+            readonly [K in keyof TDeclaredProps<TOptionsContribution<TOptions>>]?: {
+                readonly triggers?: readonly TInstanceEventName<TOptionsInstance<TOptions>>[];
+            };
+        };
+    };
+};
+/** Контракт по фабрике дескриптора (`typeof ButtonDescriptor`) или по самому дескриптору. */
+export type TContractOf<T> = T extends (...args: any[]) => IComponentDescriptor<infer C> ? C : T extends IComponentDescriptor<infer C> ? C : never;
+/** Инстанс дескриптора: DescriptorInstance<typeof ButtonDescriptor> → TButton */
+export type DescriptorInstance<T> = TContractOf<T>['instance'];
+/**
+ * Интерфейс пропсов без защищённых имён.
+ *
+ * Вычитать нечего — тип остаётся тем же самым, а не структурной копией: у
+ * подавляющего большинства компонентов защищённый проп в интерфейс пропсов
+ * ядра и не входит (`classes`, `aria` — геттеры инстанса), и `Omit` там
+ * заменил бы именованный интерфейс перечислением ключей в declaration emit.
+ */
+type TOmitProtected<TProps, TName extends string> = [Extract<keyof TProps, TName>] extends [never] ? TProps : Omit<TProps, TName>;
+/**
+ * Props компонента из дескриптора: DescriptorProps<typeof ButtonDescriptor> → IButtonProps
+ *
+ * Защищённое имя из пропсов уходит: `protected` значит «значение вычисляет
+ * владелец», и входа у разметки нет ни в рантайме (`exportProps` поверхности),
+ * ни в типе. Так переобъявление `size: { protected: true }` у элемента
+ * коллекции снимает вход, оставляя `size` в интерфейсе ядра: из данных и от
+ * владельца значение по-прежнему приходит.
+ */
+export type DescriptorProps<T> = TOmitProtected<TInstanceProps<DescriptorInstance<T>>, TContractOf<T>['protectedName']>;
+/** Own component events declared in `events`, excluding namespaced plugin events. */
+export type DescriptorEvents<T> = TPublishedEvents<DescriptorInstance<T>, TContractOf<T>['eventName']>;
+/**
+ * Все события дескриптора — свои опубликованные и плагинные (namespaced):
+ * DescriptorAllEvents<typeof ButtonDescriptor> → DescriptorEvents<…> & { 'element:ready': ... }.
+ * Из неё React, Solid и Svelte выводят колбэк-пропы, поэтому в ней только то, что адаптер пробрасывает.
+ */
+export type DescriptorAllEvents<T> = DescriptorEvents<T> & TContractOf<T>['plugins']['events'];
+/** Все пропсы дескриптора (свои + плагинные, namespaced): DescriptorAllProps<typeof ButtonDescriptor> → IButtonProps & { aria_label?: ... } */
+export type DescriptorAllProps<T> = DescriptorProps<T> & TContractOf<T>['plugins']['props'];
+/**
+ * Входы плагинов дескриптора — незащищённые пропсы плагинов:
+ * DescriptorPluginProps<typeof InputDescriptor> → { aria_label?: ...; id?: ... }
+ *
+ * Вход с триггером обмен держит в состоянии, как свойство инстанса, и
+ * разметка читает его оттуда же (`TAdapterState`): `id` поля — проп
+ * `TIdPlugin`, и, заданный полем формы, он есть только в состоянии.
+ */
+export type DescriptorPluginProps<T> = TContractOf<T>['plugins']['props'];
+/**
+ * Выходы плагинов дескриптора — защищённые пропсы, которые плагины отдают
+ * разметке: DescriptorPluginOutputs<typeof FrameDescriptor> → { layout_styles: ... }
+ *
+ * Только плагинные, без «All»: свои выходы компонента (`classes`, `aria`) —
+ * геттеры инстанса, и их тип адаптер берёт у него (`TInstanceState`).
+ */
+export type DescriptorPluginOutputs<T> = TContractOf<T>['plugins']['outputs'];
+/**
+ * Слоты дескриптора, имя → scope, — только объявленные им самим, без слотов `extends`:
+ * DescriptorSlots<typeof ButtonDescriptor> → { leading: TEmptySlotScope; default: { text: string }; trailing: TEmptySlotScope }
+ */
+export type DescriptorSlots<T> = TContractOf<T>['slots'];
+export {};

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

@@ -0,0 +1,21 @@
+/**
+ * inheritDeclarations — свои объявления поверх родительских, одним правилом на пропсы и плагины.
+ *
+ * Правило: объявление с тем же ключом ложится на родительское и остаётся на
+ * его месте, остальные встают следом. `Map.set` позицию ключа не меняет, и
+ * порядок объявлений публичен — его хранят сгенерированные метаданные Angular.
+ *
+ * Что значит «поверх», решает само объявление (`IDeclaration.inheritFrom`), а
+ * не эта функция: проп переобъявляет написанные факты, плагин встаёт
+ * целиком. Поэтому здесь нет ни ветки на категорию, ни функции извлечения
+ * ключа, а новая категория объявлений приносит своё правило с собой. Слоты
+ * сюда не ходят: они описывают разметку, а она не наследуется
+ * (`TComponentDescriptor`).
+ *
+ * Двух объявлений с одним ключом на выходе не бывает — по ключу их ровно одно.
+ * Столкновение разных источников (проп компонента и проп плагина) этим не
+ * прячется: у них разные списки, и сводит их дескриптор (`getProps`), сообщая
+ * о дубле.
+ */
+import type { IDeclaration } from './types';
+export declare function inheritDeclarations<T extends IDeclaration<T>>(parent: readonly T[], own: readonly T[]): T[];

package/dist/protected/define/inherit.js

@@ -0,0 +1,11 @@
+//#region protected/define/inherit.ts
+function inheritDeclarations(parent, own) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const declaration of [...parent, ...own]) {
+		const base = byKey.get(declaration.key);
+		byKey.set(declaration.key, base ? declaration.inheritFrom(base) : declaration);
+	}
+	return [...byKey.values()];
+}
+//#endregion
+export { inheritDeclarations };

package/dist/protected/define/name.class.d.ts

@@ -0,0 +1,21 @@
+/**
+ * TName — квалифицированное имя пропа или события: сырое имя и необязательный неймспейс плагина.
+ *
+ * - `name` — так к свойству и событию обращаются у владельца (`owner[name]`,
+ *   `events.on(name)`);
+ * - `namespace` — чей это проп: у плагина он есть, у компонента нет;
+ * - `getName()` — полное имя (`aria:label`), уникальное в составе компонента.
+ *
+ * Имя во фреймворке из него строит стратегия адаптера (`INamingStrategy`).
+ *
+ * Полное имя склеивается один раз, в конструкторе. Имя создаётся на объявление
+ * и живёт, пока жив тип, а полное имя читают на каждом монтировании: по нему
+ * обмен раскладывает события по участникам.
+ */
+export declare class TName {
+    readonly name: string;
+    readonly namespace?: string | undefined;
+    private readonly _fullName;
+    constructor(name: string, namespace?: string | undefined);
+    getName(): string;
+}

package/dist/protected/define/name.class.js

@@ -0,0 +1,31 @@
+//#region protected/define/name.class.ts
+/**
+* TName — квалифицированное имя пропа или события: сырое имя и необязательный неймспейс плагина.
+*
+* - `name` — так к свойству и событию обращаются у владельца (`owner[name]`,
+*   `events.on(name)`);
+* - `namespace` — чей это проп: у плагина он есть, у компонента нет;
+* - `getName()` — полное имя (`aria:label`), уникальное в составе компонента.
+*
+* Имя во фреймворке из него строит стратегия адаптера (`INamingStrategy`).
+*
+* Полное имя склеивается один раз, в конструкторе. Имя создаётся на объявление
+* и живёт, пока жив тип, а полное имя читают на каждом монтировании: по нему
+* обмен раскладывает события по участникам.
+*/
+var TName = class {
+	name;
+	namespace;
+	_fullName;
+	constructor(name, namespace) {
+		this.name = name;
+		this.namespace = namespace;
+		this._fullName = namespace ? `${namespace}:${name}` : name;
+		Object.freeze(this);
+	}
+	getName() {
+		return this._fullName;
+	}
+};
+//#endregion
+export { TName };

package/dist/protected/define/plugin-definition.class.d.ts

@@ -0,0 +1,45 @@
+/**
+ * TPluginDefinition — определение плагина: контракт класса и опции того места, где плагин поставили.
+ *
+ * Контракт один на класс плагина: пропсы, события и неймспейс объявляет
+ * `definePlugin`, один раз, константой модуля. Опции — свойство использования:
+ * `with(options)` отдаёт то же определение с опциями, а исходное не трогает —
+ * его делят все дескрипторы, которые плагин ставят.
+ *
+ * Умолчание пропа плагина — значение, с которым плагин стартует: заданная
+ * опция, иначе `defaultValues` класса. Опция впереди: плагин стартует с неё, и
+ * отдай адаптеру умолчание класса — Vue при монтировании перетёр бы им опцию
+ * автора дескриптора. Опция считается заданной, если она не `undefined`: так
+ * её читает сам плагин (`options?.flip ?? …`). У `defaultValues` значим ключ —
+ * см. `TPropSpec`.
+ */
+import type { TName } from './name.class';
+import type { TPropSpec } from './prop-spec.class';
+import type { IPluginContract, IPluginDefinition, TPluginCtor } from './types';
+export declare class TPluginDefinition<C extends IPluginContract> implements IPluginDefinition<C> {
+    readonly ctor: TPluginCtor;
+    readonly namespace: string | undefined;
+    private readonly _specs;
+    readonly events: readonly TName[];
+    readonly options?: object | undefined;
+    readonly __contract?: C;
+    readonly props: readonly TPropSpec[];
+    /**
+     * @param _specs пропсы contribution без умолчаний: умолчание зависит от опций
+     */
+    constructor(ctor: TPluginCtor, namespace: string | undefined, _specs: readonly TPropSpec[], events: readonly TName[], options?: object | undefined);
+    /** Ключ наследования — класс плагина: дважды один класс компоненту не ставят. */
+    get key(): TPluginCtor;
+    /**
+     * Родительское определение не читается: определение наследника заменяет его
+     * целиком. Опции — свойство места установки, а не накопленная сумма: у
+     * `DismissPluginDescriptor.with({ focusOutside: true })` наследник объявляет
+     * их заново, и наполовину родительских опций не бывает.
+     */
+    inheritFrom(): IPluginDefinition<C>;
+    /** Полный список пропсов — как у дескриптора: определение плагина тоже источник поверхности. */
+    getProps(): readonly TPropSpec[];
+    getEvents(): readonly TName[];
+    with(options: C['options']): IPluginDefinition<C>;
+    private _withDefault;
+}

package/dist/protected/define/plugin-definition.class.js

@@ -0,0 +1,49 @@
+//#region protected/define/plugin-definition.class.ts
+var TPluginDefinition = class TPluginDefinition {
+	ctor;
+	namespace;
+	_specs;
+	events;
+	options;
+	props;
+	/**
+	* @param _specs пропсы contribution без умолчаний: умолчание зависит от опций
+	*/
+	constructor(ctor, namespace, _specs, events, options) {
+		this.ctor = ctor;
+		this.namespace = namespace;
+		this._specs = _specs;
+		this.events = events;
+		this.options = options;
+		this.props = Object.freeze(_specs.map((spec) => this._withDefault(spec)));
+	}
+	/** Ключ наследования — класс плагина: дважды один класс компоненту не ставят. */
+	get key() {
+		return this.ctor;
+	}
+	/**
+	* Родительское определение не читается: определение наследника заменяет его
+	* целиком. Опции — свойство места установки, а не накопленная сумма: у
+	* `DismissPluginDescriptor.with({ focusOutside: true })` наследник объявляет
+	* их заново, и наполовину родительских опций не бывает.
+	*/
+	inheritFrom() {
+		return this;
+	}
+	/** Полный список пропсов — как у дескриптора: определение плагина тоже источник поверхности. */
+	getProps() {
+		return this.props;
+	}
+	getEvents() {
+		return this.events;
+	}
+	with(options) {
+		return new TPluginDefinition(this.ctor, this.namespace, this._specs, this.events, options);
+	}
+	_withDefault(spec) {
+		const option = this.options ? Reflect.get(this.options, spec.name.name) : void 0;
+		return option === void 0 ? spec.rebase(this.ctor.defaultValues) : spec.withDefault(option);
+	}
+};
+//#endregion
+export { TPluginDefinition };

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

@@ -0,0 +1,18 @@
+/**
+ * definePlugin infers and registers a plugin contract from its class and contribution.
+ * Public events come only from explicit `events`; property triggers refresh state and models.
+ */
+import type { IContribution } from './contribution.types';
+import type { TPluginContractFrom } from './inference.types';
+import type { IPluginDefinition, TPluginCtor } from './types';
+/**
+ * Параметры типа выводятся из опций, явно их не передают. Неймспейс и
+ * contribution — `const`: из их литералов складываются имена в контракте.
+ */
+export declare function definePlugin<TCtor extends TPluginCtor, const N extends string | undefined = undefined, const TContribution extends IContribution = IContribution>(options: {
+    ctor: TCtor;
+    namespace?: N;
+    contribution?: TContribution;
+}): IPluginDefinition<TPluginContractFrom<InstanceType<TCtor>, N, TContribution>>;
+/** Контракт плагина — его объявление `definePlugin`; нет — пропсов и событий у плагина нет. */
+export declare function pluginContractOf(ctor: TPluginCtor): IPluginDefinition | undefined;