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

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

@@ -0,0 +1,69 @@
+/**
+ * useAdapter — the one Vue hook of the project.
+ *
+ * 1. Binds the component to Vue through the exchange `adapter.connect()` in
+ *    `setup()`: the state record, the inputs, the events and `update:<prop>`
+ *    for `v-model`
+ * 2. Accepts the component: `adapter.attach()` in `setup()`
+ * 3. Binds the root DOM element to `TElementPlugin` through the context
+ * 4. Calls `adapter.detach()` when the unmount begins and `adapter.destroy()`
+ *    when it ends
+ *
+ * The template gets a view of the binding (`./view.ts`): a component with
+ * facades joins them with `joinBindings`, and adds its own values with
+ * `extendBinding`.
+ */
+import { type Ref } from 'vue';
+import { type IAdapterContext, type IComponentContract, type TInstanceState } from '@soxa-ui/setup';
+import type { IPluginBundle } from '@soxa-ui/plugins';
+/** The public properties and getters of the controller (`TInstance`), without its methods. */
+export type TExtractControllerState<TInstance> = {
+    [K in keyof TInstance as TInstance[K] extends (...args: never[]) => unknown ? never : K]: TInstance[K];
+};
+/** Props as the template sees them: refs among them are unwrapped, as a `setup()` result's are. */
+export type TUnwrapRefs<T> = {
+    [K in keyof T]: T[K] extends Ref<infer U> ? U : T[K];
+};
+/**
+ * What `useAdapter` returns and the template sees:
+ * - `ctrl` — the controller instance
+ * - `plugins` — the plugin bundle
+ * - `rootElement` — the ref of the root, when the bundle has `TElementPlugin`
+ * - the state (`TBindingState`)
+ */
+export type TBinding<C extends IComponentContract, TProps> = TBindingFields<C> & TBindingState<C, TProps>;
+/** The fields of a component's view: read before its state. */
+export type TBindingFields<C extends IComponentContract> = {
+    ctrl: C['instance'];
+    plugins: IPluginBundle | null;
+    rootElement?: Ref<Element | null>;
+};
+/**
+ * The state in types: the props `TProps`, the instance properties and the
+ * plugin outputs of the contract — the latter of the same kind as in the other
+ * adapters (`TInstanceState`): a snapshot, read-only, an optional key.
+ */
+export type TBindingState<C extends IComponentContract, TProps> = TUnwrapRefs<TProps> & TExtractControllerState<C['instance']> & TInstanceState<C['plugins']['outputs']>;
+/**
+ * The typed state record (`TBindingState`).
+ *
+ * The boundary between runtime and type, one for `useAdapter` and
+ * `useCollectionAdapter` — as `toInstanceState` in the other adapters. The
+ * record is filled by the descriptor from the same instance and the same
+ * plugins the contract `C` describes, but by property names — the descriptor
+ * holds that link, TypeScript does not see it.
+ */
+export declare function toBindingState<C extends IComponentContract, TProps>(record: Readonly<Record<string, unknown>>): TBindingState<C, TProps>;
+/**
+ * What `useAdapter` and `useCollectionAdapter` share: the subscriptions, the
+ * acceptance and the cleanup. Returns the state record of the context.
+ */
+export declare function useAdapterParts(adapter: IAdapterContext, props: object, emit?: (event: string, ...args: unknown[]) => void): Readonly<Record<string, unknown>>;
+/**
+ * The binding of a component: its fields and its state.
+ *
+ * The component writes no generics: the instance and the plugin outputs come
+ * from the contract in the context type (`createVueAdapterContext` infers it),
+ * the props from `props` themselves.
+ */
+export declare function useAdapter<C extends IComponentContract, TProps extends object>(adapter: IAdapterContext<C>, props: TProps, emit?: (event: string, ...args: unknown[]) => void): TBinding<C, TProps>;

package/dist/adapter/runtime/useAdapter.js

@@ -0,0 +1,117 @@
+import { VueProfile } from "../common/profile.js";
+import { bindingOf } from "./view.js";
+import { getCurrentInstance, onBeforeUnmount, onBeforeUpdate, onUnmounted, ref, shallowReactive, watch } from "vue";
+import { TElementPlugin } from "@soxa-ui/plugins";
+//#region src/adapter/runtime/useAdapter.ts
+/**
+* useAdapter — the one Vue hook of the project.
+*
+* 1. Binds the component to Vue through the exchange `adapter.connect()` in
+*    `setup()`: the state record, the inputs, the events and `update:<prop>`
+*    for `v-model`
+* 2. Accepts the component: `adapter.attach()` in `setup()`
+* 3. Binds the root DOM element to `TElementPlugin` through the context
+* 4. Calls `adapter.detach()` when the unmount begins and `adapter.destroy()`
+*    when it ends
+*
+* The template gets a view of the binding (`./view.ts`): a component with
+* facades joins them with `joinBindings`, and adds its own values with
+* `extendBinding`.
+*/
+/**
+* The typed state record (`TBindingState`).
+*
+* The boundary between runtime and type, one for `useAdapter` and
+* `useCollectionAdapter` — as `toInstanceState` in the other adapters. The
+* record is filled by the descriptor from the same instance and the same
+* plugins the contract `C` describes, but by property names — the descriptor
+* holds that link, TypeScript does not see it.
+*/
+function toBindingState(record) {
+	return record;
+}
+/** Adds a key to a plain record like an assignment would, but keeps the record a fast object. */
+function define(record, name, value) {
+	Object.defineProperty(record, name, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+/**
+* What `useAdapter` and `useCollectionAdapter` share: the subscriptions, the
+* acceptance and the cleanup. Returns the state record of the context.
+*/
+function useAdapterParts(adapter, props, emit) {
+	const link = adapter.connect(VueProfile);
+	const offs = [];
+	const record = {};
+	const state = shallowReactive(record);
+	offs.push(link.state.subscribe((name, value) => {
+		if (Object.hasOwn(record, name)) state[name] = value;
+		else define(record, name, value);
+	}));
+	const instance = getCurrentInstance();
+	let vnode = instance?.vnode;
+	onBeforeUpdate(() => {
+		if (!instance || instance.vnode === vnode) return;
+		vnode = instance.vnode;
+		link.inputs.full(props);
+	});
+	adapter.attach();
+	if (emit) adapter.events.on("detach", link.events.listen((name, args) => emit(name, ...args)));
+	onBeforeUnmount(() => adapter.detach());
+	onUnmounted(() => {
+		offs.forEach((off) => off());
+		adapter.destroy();
+	});
+	return state;
+}
+/**
+* The node behind a template ref: Vue puts a component's instance there when
+* the root is drawn by a component (Icon's `tag` is its glyph), and the node
+* is that instance's `$el`.
+*/
+function elementOf(root) {
+	if (root instanceof Element) return root;
+	const el = typeof root === "object" && root !== null ? Reflect.get(root, "$el") : null;
+	return el instanceof Element ? el : null;
+}
+/**
+* The ref of the root bound to `TElementPlugin`, only where the bundle has
+* the plugin: headless layers do not. A facade shares the component's bundle
+* and has no node of its own, so `useCollectionAdapter` does not call this.
+*
+* The plugin gets the node, whatever the template wrote into the ref
+* (`elementOf`): a component's instance in `TElementPlugin` gave no
+* `element:ready`, and the plugins of Icon with a glyph never got a node.
+*/
+function useRootElement(adapter) {
+	if (!adapter.bundle?.get(TElementPlugin)) return void 0;
+	const rootElement = ref(null);
+	watch(rootElement, (root) => adapter.bindElement(elementOf(root)), { flush: "post" });
+	return rootElement;
+}
+/**
+* The binding of a component: its fields and its state.
+*
+* The component writes no generics: the instance and the plugin outputs come
+* from the contract in the context type (`createVueAdapterContext` infers it),
+* the props from `props` themselves.
+*/
+function useAdapter(adapter, props, emit) {
+	const state = toBindingState(useAdapterParts(adapter, props, emit));
+	const rootElement = useRootElement(adapter);
+	const fields = rootElement ? {
+		ctrl: adapter.instance,
+		plugins: adapter.bundle,
+		rootElement
+	} : {
+		ctrl: adapter.instance,
+		plugins: adapter.bundle
+	};
+	return bindingOf(fields, state);
+}
+//#endregion
+export { toBindingState, useAdapter, useAdapterParts };

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

@@ -0,0 +1,34 @@
+import type { IAdapterContext, IComponentContract } from '@soxa-ui/setup';
+import type { IPluginBundle } from '@soxa-ui/plugins';
+import { type TBindingState } from './useAdapter';
+/**
+ * The same as `TBinding`, without `ctrl` and `rootElement`.
+ *
+ * `TProps` are the component's props, the collection ones among them; the
+ * instance of the contract `C` is the facade. From them the template gets the
+ * types of `items`, `selected` and the rest the collection hands over.
+ *
+ * Built as an intersection, not through `Omit<TBinding, …>`: `Omit` flattens
+ * the intersection, and `items` of the declared prop stops merging with
+ * `items` of the facade — the template sees a union without `uid`.
+ */
+export type TCollectionBinding<C extends IComponentContract, TProps> = {
+    plugins: IPluginBundle | null;
+} & TBindingState<C, TProps>;
+/**
+ * The adapter of a collection facade — the facade of the owner and of an item:
+ * everything `useAdapter` does except what belongs to the component.
+ *
+ * - `ctrl` of a facade would be the `T*CollectionFacade`, while the template
+ *   waits for the component under that name;
+ * - a facade has no root: it shares the component's bundle and has no node of
+ *   its own, so it gets neither a root ref nor a `watch` on it — a ref the
+ *   template never bound, on every item and owner of a collection.
+ *
+ * `plugins` stays: it is the **same** bundle for both contexts — the second
+ * one is created with `{ bundle: adapter.bundle }`.
+ *
+ * The component joins its binding with the facades' in `joinBindings` — one
+ * view, its fields first, then the states in order.
+ */
+export declare function useCollectionAdapter<C extends IComponentContract, TProps extends object>(adapter: IAdapterContext<C>, props: TProps, emit?: (event: string, ...args: unknown[]) => void): TCollectionBinding<C, TProps>;

package/dist/adapter/runtime/useCollectionAdapter.js

@@ -0,0 +1,25 @@
+import { bindingOf } from "./view.js";
+import { toBindingState, useAdapterParts } from "./useAdapter.js";
+//#region src/adapter/runtime/useCollectionAdapter.ts
+/**
+* The adapter of a collection facade — the facade of the owner and of an item:
+* everything `useAdapter` does except what belongs to the component.
+*
+* - `ctrl` of a facade would be the `T*CollectionFacade`, while the template
+*   waits for the component under that name;
+* - a facade has no root: it shares the component's bundle and has no node of
+*   its own, so it gets neither a root ref nor a `watch` on it — a ref the
+*   template never bound, on every item and owner of a collection.
+*
+* `plugins` stays: it is the **same** bundle for both contexts — the second
+* one is created with `{ bundle: adapter.bundle }`.
+*
+* The component joins its binding with the facades' in `joinBindings` — one
+* view, its fields first, then the states in order.
+*/
+function useCollectionAdapter(adapter, props, emit) {
+	const state = toBindingState(useAdapterParts(adapter, props, emit));
+	return bindingOf({ plugins: adapter.bundle }, state);
+}
+//#endregion
+export { useCollectionAdapter };

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

@@ -0,0 +1,53 @@
+/**
+ * The binding view — what `setup()` of a component hands its template.
+ *
+ * One `Proxy` per component with a handler shared by the module. It reads the
+ * view's fields first — `ctrl`, `plugins`, `rootElement` and the component's
+ * own values — and then the state records of its contexts in order: the
+ * component's, then its facades'. Facade names are prefixed
+ * (docs/agents/collections.md, «Имена props фасада префиксуются»), so no name
+ * lives in two records.
+ *
+ * A state record is `shallowReactive` and written by the binding's
+ * subscription. Vue creates a `Dep` for a key only when an effect reads it —
+ * the render: a property the markup does not read costs a slot of the record
+ * and nothing else, and a read on the server or in `setup()` creates nothing.
+ * A `shallowRef` per property cost a `RefImpl` and a `Dep` on every property,
+ * read by the markup or not — and it reads fewer than half of them
+ * (benchmarks/pages/vue.md, 869fmjnaq).
+ *
+ * Not a getter per property: a closure over the context with a pair of
+ * accessors weighs about as much as the `RefImpl` with its `Dep`. Not a
+ * spread: it reads every value once, in `setup()`, and unties the markup from
+ * the core — hence `joinBindings` and `extendBinding`, which build one flat
+ * view again.
+ *
+ * Presence, keys and descriptors come from the records themselves, untracked:
+ * Vue looks a template name up with `hasOwn` on the `setup()` result and, in
+ * development, lists its keys. A key with the value `undefined` is present:
+ * the subscription hands every property over at once, and a name Vue did not
+ * find there on the first read it resolves elsewhere for good. The view is
+ * read-only — the state goes core → Vue only; the template ref reaches
+ * `rootElement` through the ref itself, the way `proxyRefs` writes a ref.
+ */
+/**
+ * The view of a context: its fields, then its state record. The boundary
+ * between runtime and type, as `toInstanceState` in the other adapters: the
+ * proxy reads every field and every property of the state, but TypeScript
+ * does not see that.
+ */
+export declare function bindingOf<TFields extends object, TState extends object>(fields: TFields, state: TState): TFields & TState;
+/**
+ * The binding of a component and its facades — one view for the markup: the
+ * fields of all of them, the component's winning (a facade carries only the
+ * same bundle in `plugins`), and their states in order. The hooks are still
+ * called in their order: `attach` and `onUnmounted` go by it.
+ */
+export declare function joinBindings<TOwner extends object, TFacade extends object>(owner: TOwner, facade: TFacade): TOwner & TFacade;
+export declare function joinBindings<TOwner extends object, TFacade extends object, TOwnerFacade extends object>(owner: TOwner, facade: TFacade, ownerFacade: TOwnerFacade): TOwner & TFacade & TOwnerFacade;
+/**
+ * The binding with the component's own values — icon tags, an inner instance,
+ * attribute groups: they win over a state property of the same name, as a
+ * spread after the binding did.
+ */
+export declare function extendBinding<TView extends object, TValues extends object>(binding: TView, values: TValues): Omit<TView, keyof TValues> & TValues;

package/dist/adapter/runtime/view.js

@@ -0,0 +1,103 @@
+import { toRaw } from "vue";
+//#region src/adapter/runtime/view.ts
+/**
+* The binding view — what `setup()` of a component hands its template.
+*
+* One `Proxy` per component with a handler shared by the module. It reads the
+* view's fields first — `ctrl`, `plugins`, `rootElement` and the component's
+* own values — and then the state records of its contexts in order: the
+* component's, then its facades'. Facade names are prefixed
+* (docs/agents/collections.md, «Имена props фасада префиксуются»), so no name
+* lives in two records.
+*
+* A state record is `shallowReactive` and written by the binding's
+* subscription. Vue creates a `Dep` for a key only when an effect reads it —
+* the render: a property the markup does not read costs a slot of the record
+* and nothing else, and a read on the server or in `setup()` creates nothing.
+* A `shallowRef` per property cost a `RefImpl` and a `Dep` on every property,
+* read by the markup or not — and it reads fewer than half of them
+* (benchmarks/pages/vue.md, 869fmjnaq).
+*
+* Not a getter per property: a closure over the context with a pair of
+* accessors weighs about as much as the `RefImpl` with its `Dep`. Not a
+* spread: it reads every value once, in `setup()`, and unties the markup from
+* the core — hence `joinBindings` and `extendBinding`, which build one flat
+* view again.
+*
+* Presence, keys and descriptors come from the records themselves, untracked:
+* Vue looks a template name up with `hasOwn` on the `setup()` result and, in
+* development, lists its keys. A key with the value `undefined` is present:
+* the subscription hands every property over at once, and a name Vue did not
+* find there on the first read it resolves elsewhere for good. The view is
+* read-only — the state goes core → Vue only; the template ref reaches
+* `rootElement` through the ref itself, the way `proxyRefs` writes a ref.
+*/
+/** What a view reads: its fields, then the state records in order. */
+var TViewParts = class {
+	fields;
+	states;
+	constructor(fields, states) {
+		this.fields = fields;
+		this.states = states;
+	}
+};
+/** The parts behind a view: only joining and extending ask for them. */
+var PARTS = Symbol("soxa.binding.parts");
+/** Where the key lives — the fields or a state record. Reads no value and tracks nothing. */
+function sourceOf({ fields, states }, key) {
+	if (Object.hasOwn(fields, key)) return fields;
+	for (const state of states) if (Object.hasOwn(state, key)) return state;
+}
+var VIEW = {
+	get: (parts, key) => {
+		if (key === PARTS) return parts;
+		const source = sourceOf(parts, key);
+		return source && Reflect.get(source, key);
+	},
+	has: (parts, key) => sourceOf(parts, key) !== void 0,
+	ownKeys: ({ fields, states }) => [.../* @__PURE__ */ new Set([...Reflect.ownKeys(fields), ...states.flatMap((state) => Reflect.ownKeys(toRaw(state)))])],
+	getOwnPropertyDescriptor: (parts, key) => {
+		const source = sourceOf(parts, key);
+		return source && Reflect.getOwnPropertyDescriptor(source, key);
+	},
+	set: () => false,
+	defineProperty: () => false,
+	deleteProperty: () => false
+};
+function viewOf(fields, states) {
+	return new Proxy(new TViewParts(fields, states), VIEW);
+}
+function partsOf(binding) {
+	const parts = Reflect.get(binding, PARTS);
+	if (!(parts instanceof TViewParts)) throw new Error("[soxa] Not a binding: expected the result of useAdapter or useCollectionAdapter");
+	return parts;
+}
+/**
+* The view of a context: its fields, then its state record. The boundary
+* between runtime and type, as `toInstanceState` in the other adapters: the
+* proxy reads every field and every property of the state, but TypeScript
+* does not see that.
+*/
+function bindingOf(fields, state) {
+	return viewOf(fields, [state]);
+}
+function joinBindings(owner, ...facades) {
+	const parts = [owner, ...facades].map(partsOf);
+	const fields = {};
+	for (const part of [...parts].reverse()) Object.assign(fields, part.fields);
+	return viewOf(fields, parts.flatMap(({ states }) => states));
+}
+/**
+* The binding with the component's own values — icon tags, an inner instance,
+* attribute groups: they win over a state property of the same name, as a
+* spread after the binding did.
+*/
+function extendBinding(binding, values) {
+	const { fields, states } = partsOf(binding);
+	return viewOf({
+		...fields,
+		...values
+	}, states);
+}
+//#endregion
+export { bindingOf, extendBinding, joinBindings };

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

@@ -0,0 +1,4 @@
+export { useProps } from './useProps';
+export { useEmits } from './useEmits';
+export { useExpose } from './useExpose';
+export type { TClosedComponent, TClosedInstance } from './useExpose';

package/dist/adapter/static/useEmits.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Статический хелпер для сборки emits во Vue Options API (base.component.ts).
+ *
+ * Выполняется на этапе объявления компонента (Build Time),
+ * не имеет сайд-эффектов и не тянет реактивный runtime.
+ */
+import { type IComponentDescriptor } from '@soxa-ui/setup';
+/**
+ * События ядра, триггеры свойств и `update:<prop>` для `v-model` — всё из
+ * поверхности: объявление и эмит ходят по ней одной, иначе Vue ругался бы на
+ * необъявленное событие.
+ */
+export declare function useEmits(descriptor: IComponentDescriptor): string[];

package/dist/adapter/static/useEmits.js

@@ -0,0 +1,19 @@
+import { VueProfile } from "../common/profile.js";
+import { TSurface } from "@soxa-ui/setup";
+//#region src/adapter/static/useEmits.ts
+/**
+* Статический хелпер для сборки emits во Vue Options API (base.component.ts).
+*
+* Выполняется на этапе объявления компонента (Build Time),
+* не имеет сайд-эффектов и не тянет реактивный runtime.
+*/
+/**
+* События ядра, триггеры свойств и `update:<prop>` для `v-model` — всё из
+* поверхности: объявление и эмит ходят по ней одной, иначе Vue ругался бы на
+* необъявленное событие.
+*/
+function useEmits(descriptor) {
+	return [...TSurface.of(descriptor, VueProfile).exportEvents];
+}
+//#endregion
+export { useEmits };

package/dist/adapter/static/useExpose.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The closed instance: what the consumer's `ref` sees of a component.
+ *
+ * A component has two control surfaces — props with events, and `ctrl`
+ * (AGENTS.md, «Две поверхности управления») — and `ref` is the way to the
+ * root, `$el`, not a third one. So the instance is closed from outside: it
+ * gives the own properties of Vue (`$el`, `$props`, `$slots`…) and not the
+ * bindings of the template — `ctrl`, the state, the outputs of plugins. The
+ * root `$el` comes from Vue itself, and for a component whose template root is
+ * a teleport, from `exposeRoot`.
+ *
+ * Two records close it, the run time and the type, and both are needed:
+ * vue-tsc checks the template of a component by the public type of its
+ * instance, so an option the type sees would close the template too.
+ *
+ * - `useExpose()` — the `expose` option of a component (`setup.component.ts`),
+ *   closes the instance at run time;
+ * - `TClosedComponent` — the type of a component at its export, closes the
+ *   instance in the type.
+ */
+import type { ComponentCustomProperties, ComponentPublicInstance } from 'vue';
+/**
+ * The `expose` option of a component: an empty list — the instance opens
+ * nothing but the properties of Vue.
+ *
+ * Every component has its own: Vue does not take it from `extends` (it warns
+ * and ignores it), so `base.component.ts` has none.
+ *
+ * The type is `string[]`, not an empty tuple: from `expose: []` vue-tsc would
+ * infer the closed type of the instance and check the template of the
+ * component by it too — every binding would vanish from the template. The
+ * type is closed by `TClosedComponent`.
+ */
+export declare function useExpose(): string[];
+/**
+ * The named keys of a type, without its index signatures: `string`, `number`
+ * and patterns such as `$${string}`. An object with no properties
+ * (`Record<never, never>`) satisfies an index signature and never a named key.
+ */
+type TNamedKeys<T> = keyof {
+    [K in keyof T as Record<never, never> extends Record<K, unknown> ? never : K]: T[K];
+};
+/**
+ * The properties Vue gives on the closed instance: `$el`, `$props`, `$slots`,
+ * `$emit`… The globals of the application (`ComponentCustomProperties`) the
+ * closed instance does not give. Only the named ones are subtracted: Nuxt
+ * types the injections of its plugins with a pattern, `$${string}`, and
+ * subtracting it would take `$props` away and with it the check of the props
+ * in templates.
+ */
+type TInstanceKeys = Exclude<TNamedKeys<ComponentPublicInstance>, TNamedKeys<ComponentCustomProperties>>;
+/** The closed instance in the type: only the properties of Vue, no template bindings. */
+export type TClosedInstance<TInstance extends ComponentPublicInstance> = Pick<TInstance, TInstanceKeys>;
+/**
+ * A component whose instance is closed (`useExpose`): its props, events and
+ * slots stay — vue-tsc takes them from `$props`, `$emit` and `$slots` — while
+ * the instance from `ref` is typed by the properties of Vue.
+ *
+ * The type is set at the export of the component, not by an option: the
+ * template needs the open type, the consumer the closed one (see the head of
+ * the file). There is no cast here: the open instance is a subtype of the
+ * closed one, and the component is assigned to this type as it is, under the
+ * check of the compiler.
+ *
+ * The constructor is replaced as a whole (`Omit` drops the signature of the
+ * original): with two `new` signatures the original, open one would be chosen.
+ */
+export type TClosedComponent<TComponent extends new (...args: any[]) => ComponentPublicInstance> = Omit<TComponent, never> & (new (...args: any[]) => TClosedInstance<InstanceType<TComponent>>);
+export {};

package/dist/adapter/static/useExpose.js

@@ -0,0 +1,18 @@
+//#region src/adapter/static/useExpose.ts
+/**
+* The `expose` option of a component: an empty list — the instance opens
+* nothing but the properties of Vue.
+*
+* Every component has its own: Vue does not take it from `extends` (it warns
+* and ignores it), so `base.component.ts` has none.
+*
+* The type is `string[]`, not an empty tuple: from `expose: []` vue-tsc would
+* infer the closed type of the instance and check the template of the
+* component by it too — every binding would vanish from the template. The
+* type is closed by `TClosedComponent`.
+*/
+function useExpose() {
+	return [];
+}
+//#endregion
+export { useExpose };

package/dist/adapter/static/useProps.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Статический хелпер для сборки props во Vue Options API (base.component.ts).
+ *
+ * Выполняется на этапе объявления компонента (Build Time),
+ * не имеет сайд-эффектов и не тянет реактивный runtime.
+ */
+import { type IComponentDescriptor } from '@soxa-ui/setup';
+export declare function useProps(descriptor: IComponentDescriptor): Record<string, unknown>;

package/dist/adapter/static/useProps.js

@@ -0,0 +1,16 @@
+import { VueProfile } from "../common/profile.js";
+import { TSurface } from "@soxa-ui/setup";
+//#region src/adapter/static/useProps.ts
+/**
+* Статический хелпер для сборки props во Vue Options API (base.component.ts).
+*
+* Выполняется на этапе объявления компонента (Build Time),
+* не имеет сайд-эффектов и не тянет реактивный runtime.
+*/
+function useProps(descriptor) {
+	const vueProps = {};
+	for (const [propName, config] of Object.entries(TSurface.of(descriptor, VueProfile).exportProps)) vueProps[propName] = { ...config };
+	return vueProps;
+}
+//#endregion
+export { useProps };

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

@@ -0,0 +1,3 @@
+export { useToasts } from './useToasts';
+export { isToastRender } from './render';
+export type { TToastRender } from './types';

package/dist/adapter/toasts/render.d.ts

@@ -0,0 +1,8 @@
+import type { TToastRender } from './types';
+/**
+ * Своё содержимое тоста — компонент Vue: объект определения или функция
+ * (функциональный компонент, класс). Ядро держит `render` как `unknown`, и
+ * разметка тоста рисует его, только когда это компонент: проверкой, а не
+ * приведением.
+ */
+export declare function isToastRender(value: unknown): value is TToastRender;

package/dist/adapter/toasts/render.js

@@ -0,0 +1,12 @@
+//#region src/adapter/toasts/render.ts
+/**
+* Своё содержимое тоста — компонент Vue: объект определения или функция
+* (функциональный компонент, класс). Ядро держит `render` как `unknown`, и
+* разметка тоста рисует его, только когда это компонент: проверкой, а не
+* приведением.
+*/
+function isToastRender(value) {
+	return typeof value === "function" || typeof value === "object" && value !== null;
+}
+//#endregion
+export { isToastRender };

package/dist/adapter/toasts/types.d.ts

@@ -0,0 +1,11 @@
+import type { Component } from 'vue';
+import type { IToastsItem } from '@soxa-ui/core';
+/**
+ * Своё содержимое тоста во Vue (`render`) — компонент, которому тост приходит
+ * пропом `toast`: кнопка «Отменить» внутри может его закрыть
+ * (`toast.close()`). Ядро значение не читает, поэтому там оно `unknown`, а
+ * тип ему даёт API адаптера (`useToasts()`).
+ */
+export type TToastRender = Component<{
+    toast: IToastsItem;
+}>;

package/dist/adapter/toasts/useToasts.d.ts

@@ -0,0 +1,17 @@
+import type { IToastsApi } from '@soxa-ui/core';
+import type { TToastRender } from './types';
+/**
+ * API тостов ближайшего `<Toasts>` выше по дереву: `const { show } = useToasts()`.
+ *
+ * Менеджер опускает API лифтом (`TToastsApiExtension`), и здесь он берётся тем
+ * же лифтом — `inject` Vue, поэтому звать `useToasts()` можно только
+ * синхронно в `setup()` компонента под менеджером. `show` — поле со стрелкой:
+ * деструктуризация не теряет `this`.
+ *
+ * Своё содержимое (`render`) здесь типизировано компонентом Vue с пропом
+ * `toast`: ядро значение не читает, и тип ему даёт адаптер.
+ *
+ * Менеджера выше нет — ошибка: тост показать негде, и молчаливый `show`,
+ * который ничего не делает, спрятал бы забытый `<Toasts>`.
+ */
+export declare function useToasts(): IToastsApi<TToastRender>;

package/dist/adapter/toasts/useToasts.js

@@ -0,0 +1,24 @@
+import { VueElevatorFactory } from "../elevator/factory.js";
+import { TOASTS_ELEVATOR } from "@soxa-ui/setup";
+//#region src/adapter/toasts/useToasts.ts
+/**
+* API тостов ближайшего `<Toasts>` выше по дереву: `const { show } = useToasts()`.
+*
+* Менеджер опускает API лифтом (`TToastsApiExtension`), и здесь он берётся тем
+* же лифтом — `inject` Vue, поэтому звать `useToasts()` можно только
+* синхронно в `setup()` компонента под менеджером. `show` — поле со стрелкой:
+* деструктуризация не теряет `this`.
+*
+* Своё содержимое (`render`) здесь типизировано компонентом Vue с пропом
+* `toast`: ядро значение не читает, и тип ему даёт адаптер.
+*
+* Менеджера выше нет — ошибка: тост показать негде, и молчаливый `show`,
+* который ничего не делает, спрятал бы забытый `<Toasts>`.
+*/
+function useToasts() {
+	const api = VueElevatorFactory(TOASTS_ELEVATOR).up();
+	if (!api) throw new Error("useToasts(): выше по дереву нет <Toasts>. Оберните приложение менеджером: <Toasts><App /></Toasts>");
+	return api;
+}
+//#endregion
+export { useToasts };