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

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

@@ -0,0 +1,23 @@
+/**
+ * Регистрация элементов с защитой от повторной (HMR, тесты) и признаком
+ * «ожил при регистрации»: такую разметку база откладывает в очередь
+ * регистрации, а собирает её регистрация, когда оживлять больше некого — в
+ * браузере сразу после синхронной части, с полифилом в Safari после его
+ * микрозадач оживления. AGENTS.md (Web Components), «Регистрация и полифил».
+ */
+import '@ungap/custom-elements';
+export type TRegistration = {
+    readonly name: string;
+    readonly tag: string;
+};
+export declare function registrationOf(ctor: object): TRegistration | undefined;
+export declare function isUpgradedOnRegistration(element: Element): boolean;
+/** Ждёт ли снимок оживления элемента выше по месту: теневые корни снимок не видит. */
+export declare function isUnderUpgrade(node: Node): boolean;
+/** Элемент, расширяющий встроенный элемент тега: `<button is="so-button">`. */
+export declare function defineElement(name: string, ctor: CustomElementConstructor, tag: string): void;
+/**
+ * Автономный элемент без коробки — тот, у которого в остальных адаптерах узла
+ * нет: `<so-locale-provider>`, `<so-virtual>`, `<so-toasts>`.
+ */
+export declare function defineAutonomousElement(name: string, ctor: CustomElementConstructor): void;

package/dist/adapter/runtime/defineElement.js

@@ -0,0 +1,97 @@
+import { TPlaceContext } from "../context/place-context.class.js";
+import { TDeferral } from "./deferral.js";
+import "@ungap/custom-elements";
+//#region src/adapter/runtime/defineElement.ts
+/** Идёт `customElements.define`: браузер оживляет разметку внутри него. */
+var defining = false;
+/** Фаза, чей снимок впереди: встроенные имена фазы. */
+var phase;
+/** Элементы, которых снимок ждёт от полифила. */
+var expected = /* @__PURE__ */ new Set();
+/** Сколько снимков ждут конца своей фазы. */
+var ending = 0;
+/** Класс → имя и тег, под которыми он зарегистрирован: по ним шаблон строит его узел. */
+var registrations = /* @__PURE__ */ new WeakMap();
+function registrationOf(ctor) {
+	return registrations.get(ctor);
+}
+function isUpgradedOnRegistration(element) {
+	return defining || expected.has(element);
+}
+/** Ждёт ли снимок оживления элемента выше по месту: теневые корни снимок не видит. */
+function isUnderUpgrade(node) {
+	if (expected.size === 0) return false;
+	for (const place of TPlaceContext.ancestors(node)) if (expected.has(place)) return true;
+	return false;
+}
+/** Встроенные элементы с именами фазы, ещё не ставшие экземплярами своего класса. */
+function awaited(names) {
+	if (names.size === 0) return [];
+	const selector = [...names].map(([name, { tag }]) => `${tag}[is="${name}"]`).join(",");
+	return [...document.querySelectorAll(selector)].filter((element) => {
+		const builtIn = names.get(element.getAttribute("is") ?? "");
+		return builtIn !== void 0 && !(element instanceof builtIn.ctor);
+	});
+}
+function settle() {
+	if (phase !== void 0 || ending > 0) return;
+	TDeferral.registration.release();
+}
+/** Снимок фазы — один обход документа на все её регистрации. */
+function snapshot(names) {
+	phase = void 0;
+	const waiting = awaited(names);
+	if (waiting.length === 0) {
+		settle();
+		return;
+	}
+	for (const element of waiting) expected.add(element);
+	ending += 1;
+	queueMicrotask(() => {
+		for (const element of waiting) expected.delete(element);
+		ending -= 1;
+		settle();
+	});
+}
+function enter(name, ctor, tag) {
+	let names = phase;
+	if (names === void 0) {
+		const opened = /* @__PURE__ */ new Map();
+		phase = opened;
+		names = opened;
+		queueMicrotask(() => snapshot(opened));
+	}
+	if (tag !== void 0) names.set(name, {
+		ctor,
+		tag
+	});
+}
+function register(name, ctor, options) {
+	if (typeof customElements === "undefined") return;
+	if (customElements.get(name)) return;
+	enter(name, ctor, options?.extends);
+	const outer = defining;
+	defining = true;
+	try {
+		customElements.define(name, ctor, options);
+	} finally {
+		defining = outer;
+	}
+}
+/** Элемент, расширяющий встроенный элемент тега: `<button is="so-button">`. */
+function defineElement(name, ctor, tag) {
+	registrations.set(ctor, {
+		name,
+		tag
+	});
+	register(name, ctor, { extends: tag });
+}
+/**
+* Автономный элемент без коробки — тот, у которого в остальных адаптерах узла
+* нет: `<so-locale-provider>`, `<so-virtual>`, `<so-toasts>`.
+*/
+function defineAutonomousElement(name, ctor) {
+	register(name, ctor);
+}
+//#endregion
+export { defineAutonomousElement, defineElement, isUnderUpgrade, isUpgradedOnRegistration, registrationOf };

package/dist/adapter/runtime/display-contents.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Элемент без своей коробки: теневой корень несёт только `<slot>` и правило
+ * `:host`, содержимое остаётся светом, а `display` потребителя главнее.
+ */
+export declare function displayContents(element: HTMLElement): void;

package/dist/adapter/runtime/display-contents.js

@@ -0,0 +1,14 @@
+//#region src/adapter/runtime/display-contents.ts
+var HOST_STYLE = ":host { display: contents }";
+/**
+* Элемент без своей коробки: теневой корень несёт только `<slot>` и правило
+* `:host`, содержимое остаётся светом, а `display` потребителя главнее.
+*/
+function displayContents(element) {
+	const { ownerDocument } = element;
+	const style = ownerDocument.createElement("style");
+	style.textContent = HOST_STYLE;
+	element.attachShadow({ mode: "open" }).append(style, ownerDocument.createElement("slot"));
+}
+//#endregion
+export { displayContents };

package/dist/adapter/runtime/element.base.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Element base: a built-in element of a tag, extended by the component's class
+ * (customized built-in). `<button is="so-button">` is a real button, and its
+ * form, `<label>`, focus and accessibility are native. The factory
+ * `ElementBase(HTMLButtonElement, spec)` builds the class over the tag's native
+ * class: one base, a native class per tag.
+ *
+ * The template structure and the light are built once, on the first
+ * connection. Each connection is a new binding over the same instance and a
+ * full paint; a disconnection drops the binding. A first connection that comes
+ * too early goes to the deferral queue, one inside another's connection waits
+ * for it. Updates are targeted: names of changed props gather until a
+ * microtask, and the flush applies only their bindings. AGENTS.md (Web
+ * Components), «База элемента».
+ */
+import '@ungap/custom-elements';
+import type { IComponent, IComponentProps } from '@soxa-ui/core';
+import { type DescriptorComponentProps, type IComponentDescriptor } from '@soxa-ui/setup';
+import { type THostProp } from '../common';
+import type { ITemplate } from '../template';
+import { type TRootSpec } from './root';
+import type { TBinding, TBindingState, TUpdateListener } from './useAdapter';
+export interface IElementBase<TInstance, TFacade = unknown, TOwnerFacade = unknown> {
+    readonly state: TBindingState<TInstance, TFacade, unknown, TOwnerFacade>;
+    /** The next assembly gets the instance of the first one: a move doesn't replace `el.ctrl`. */
+    ctrl: TInstance | undefined;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+}
+/**
+ * Prop properties on the prototype: the descriptor's contract, like React and
+ * Solid props, minus what the element has by its tag, `HOST_PROPS` and `ctrl`.
+ */
+export type TElementProps<TDescriptorFn extends (...args: any[]) => IComponentDescriptor, TNative extends HTMLElement> = Omit<DescriptorComponentProps<TDescriptorFn>, keyof TNative | THostProp | 'ctrl'>;
+export type TDescriptorFactory = () => IComponentDescriptor;
+/** Own attributes as properties: the value is the attribute, `null` without it; `undefined` and `null` remove it. */
+export type TOwnAttributes<TOwn extends string> = {
+    [K in TOwn]: string | null | undefined;
+};
+/** Element type: the tag's native element, the base's members, prop and own attribute properties. */
+export type TElementOf<TNative extends HTMLElement, TDescriptor extends TDescriptorFactory, TInstance, TFacade = unknown, TOwnerFacade = unknown, TOwn extends string = never> = TNative & IElementBase<TInstance, TFacade, TOwnerFacade> & TElementProps<TDescriptor, TNative> & TOwnAttributes<TOwn>;
+/** `TOutputs` are the outputs of the descriptor's plugins: the template reads them typed in the state. */
+export interface IElementSpec<TInstance, TFacade = unknown, TOutputs = unknown, TOwnerFacade = unknown, TDescriptor extends TDescriptorFactory = TDescriptorFactory, TOwn extends string = never> {
+    readonly descriptor: TDescriptor;
+    /** Descriptor of the collection facade: its props are inputs of the element too. */
+    readonly facade?: TDescriptorFactory;
+    /** Descriptor of the facade of its own collection, on an item with a submenu. */
+    readonly ownerFacade?: TDescriptorFactory;
+    readonly template: ITemplate<TInstance, TFacade, TOutputs, TOwnerFacade>;
+    readonly root?: TRootSpec;
+    /** Own attributes beyond props (`icon`): the attribute holds the value, the property reflects it. */
+    readonly attributes?: readonly TOwn[];
+    setup(host: HTMLElement, ctrl: TInstance | undefined, props: Record<string, unknown>, onUpdate: TUpdateListener): TBinding<TInstance, TFacade, TOutputs, TOwnerFacade>;
+}
+/** Rest `any[]` is the mixin constructor shape: without it the base class doesn't combine with the native one. */
+export type TNativeElementClass = new (...args: any[]) => HTMLElement;
+/**
+ * `instanceof` with the class narrows a node to the element with its full
+ * type, by the predicate of `[Symbol.hasInstance]` (TypeScript 5.3+): the base
+ * sets the prop properties on the prototype at run time, and the instance type
+ * of the class doesn't know them. `prototype` and the constructor stay native:
+ * typed as the element, they would not hold for the class the base builds
+ * without a cast.
+ */
+export type TElementClass<TInstance, TFacade = unknown, TOwnerFacade = unknown, TElement = IElementBase<TInstance, TFacade, TOwnerFacade>> = (new (...args: any[]) => IElementBase<TInstance, TFacade, TOwnerFacade>) & {
+    readonly observedAttributes: string[];
+    [Symbol.hasInstance](node: unknown): node is TElement;
+};
+/**
+ * Element class by the tag's native class and the descriptor. The annotation of
+ * an element export: the declaration names the descriptor (`typeof
+ * ButtonDescriptor`) instead of spelling out the inferred type.
+ */
+export type TElementClassOf<TNative extends TNativeElementClass, TDescriptor extends TDescriptorFactory, TInstance, TFacade = unknown, TOwnerFacade = unknown, TOwn extends string = never> = TNative & TElementClass<TInstance, TFacade, TOwnerFacade, TElementOf<InstanceType<TNative>, TDescriptor, TInstance, TFacade, TOwnerFacade, TOwn>>;
+/** Element type of a class: `TElementType<typeof TButtonElement>`. */
+export type TElementType<TClass> = TClass extends {
+    [Symbol.hasInstance](node: unknown): node is infer T;
+} ? T : never;
+/**
+ * The result type is declared: TypeScript doesn't emit a class inferred from an
+ * expression into a declaration, it has private members.
+ */
+export declare function ElementBase<TNative extends TNativeElementClass, TInstance extends IComponent<IComponentProps, any>, TFacade = unknown, TOutputs = unknown, TOwnerFacade = unknown, TDescriptor extends TDescriptorFactory = TDescriptorFactory, TOwn extends string = never>(Native: TNative, spec: IElementSpec<TInstance, TFacade, TOutputs, TOwnerFacade, TDescriptor, TOwn>): TElementClassOf<TNative, TDescriptor, TInstance, TFacade, TOwnerFacade, TOwn>;

package/dist/adapter/runtime/element.base.js

@@ -0,0 +1,347 @@
+import { WebcProfile } from "../common/profile.js";
+import { buildAttributeMap, coerceAttribute, isHostProp, toAttributeName } from "../common/attributes.js";
+import "../common/index.js";
+import { TElementAttributes, TPaint, classesOf, orderOf, setOf, stylesOf } from "./paint.js";
+import { markPlaceOwner } from "./marks.js";
+import { keepsBinding } from "./relocation.js";
+import { connecting, isConnecting, wait } from "./waiting.js";
+import { TTeleport } from "./teleport.js";
+import { TDeferral } from "./deferral.js";
+import { isUnderUpgrade, isUpgradedOnRegistration } from "./defineElement.js";
+import { TLight } from "./light.js";
+import { TPropStore } from "./props.js";
+import { placeOf, planOf, presenceOf } from "./root.js";
+import { TSubtree, followAbove, provideSubtree } from "./subtree.js";
+import { TSurface } from "@soxa-ui/setup";
+import "@ungap/custom-elements";
+//#region src/adapter/runtime/element.base.ts
+/**
+* The `id` attribute is a prop of `TIdPlugin`. On a root with a field it is the
+* field's prop, not an input of the root: two nodes with one `id` would break
+* `<label for>`. A root without a field carries the `id` itself (a tab panel),
+* and there the attribute is an input.
+*/
+var ID = "id";
+/** `id` from the attribute: an empty one removes the prop, like a native `id`. */
+function idOf(raw) {
+	return raw === null || raw === "" ? void 0 : raw;
+}
+/** An own prop wins over a facade prop of the same name: both bindings get the delta. */
+function attributesOf(descriptors) {
+	const map = /* @__PURE__ */ new Map();
+	for (const descriptor of descriptors) for (const [name, binding] of buildAttributeMap(descriptor)) if (!map.has(name)) map.set(name, binding);
+	return map;
+}
+/** The root spec names a node the template didn't build: nowhere to carry it. */
+function built(node, what) {
+	if (!node) throw new Error(`[soxa] Описание корня объявляет ${what}, а шаблон его не построил`);
+	return node;
+}
+/**
+* The result type is declared: TypeScript doesn't emit a class inferred from an
+* expression into a declaration, it has private members.
+*/
+function ElementBase(Native, spec) {
+	const descriptors = [
+		spec.descriptor(),
+		spec.facade?.(),
+		spec.ownerFacade?.()
+	].filter((descriptor) => descriptor !== void 0);
+	const plan = planOf(spec.root);
+	const attributes = attributesOf(descriptors);
+	if (plan.fieldId && !attributes.has(ID)) throw new Error("[soxa] Описание корня объявляет id поля, а у дескриптора пропа id нет");
+	const fieldId = (plan.control || plan.fieldId) && attributes.has(ID);
+	if (fieldId) attributes.delete(ID);
+	/** Prop inputs on the root: their value in the core's set is always right. A wrapper has none. */
+	const inputs = new Set(plan.wrapped ? [] : attributes.keys());
+	/** Own attributes: attribute name → property name. */
+	const own = new Map((spec.attributes ?? []).map((name) => [toAttributeName(name), name]));
+	class TElementBase extends Native {
+		static get observedAttributes() {
+			return [
+				...attributes.keys(),
+				...own.keys(),
+				...fieldId ? [ID] : []
+			];
+		}
+		/**
+		* The inherited check, typed with the element: through `super`, since
+		* `instanceof` the class itself would call this method again. The
+		* polyfill leaves `Symbol.hasInstance` of the native classes alone.
+		*/
+		static [Symbol.hasInstance](node) {
+			return super[Symbol.hasInstance](node);
+		}
+		_binding;
+		_ctrl;
+		_props = new TPropStore();
+		_light = new TLight(this);
+		_dirty = /* @__PURE__ */ new Set();
+		_flushQueued = false;
+		_connected = false;
+		/** In the deferral queue or waiting for another element's connection. */
+		_deferred = false;
+		/** The node that gets what the core writes and goes to `TElementPlugin`. */
+		_root = this;
+		/** The outer node: hiding goes on it. */
+		_outer = this;
+		_companion = null;
+		_teleport;
+		/** The root is in its place: a layer's root is in the target or in place. */
+		_placed = true;
+		/** Own subtree flag, one for the whole lifetime. */
+		_subtree = new TSubtree();
+		/** The ancestor's flag, for this assembly. */
+		_above;
+		_view = this._viewOf();
+		constructor(...args) {
+			super(...args);
+			markPlaceOwner(this);
+			provideSubtree(this, this._subtree);
+			if (plan.control) TElementAttributes.of(this).awaitField();
+		}
+		get state() {
+			return this._binding?.state ?? {};
+		}
+		get ctrl() {
+			return this._binding?.ctrl ?? this._ctrl;
+		}
+		set ctrl(value) {
+			this._ctrl = value;
+		}
+		connectedCallback() {
+			if (!this.isConnected) return;
+			if (this._connected || this._deferred) return;
+			const deferral = this._light.built ? void 0 : this._deferralOf();
+			if (deferral) {
+				this._deferred = true;
+				deferral.defer(this, this._resume);
+				return;
+			}
+			if (isConnecting()) {
+				this._deferred = true;
+				wait(this._resume);
+				return;
+			}
+			connecting(() => this._connect());
+		}
+		disconnectedCallback() {
+			if (keepsBinding(this)) return;
+			this._connected = false;
+			this._above?.stop();
+			this._above = void 0;
+			this._binding?.detach();
+			this._binding?.destroy();
+			this._binding = void 0;
+			this._teleport?.release();
+			if (!this.isConnected) TTeleport.recall(this);
+		}
+		attributeChangedCallback(name, _old, value) {
+			if (fieldId && name === ID) {
+				if (value !== null) this._takeFieldId();
+				return;
+			}
+			if (name === ID && attributes.has(ID)) {
+				if (value === null || TElementAttributes.of(this).wanted(name) !== value) this._write(ID, idOf(value));
+				return;
+			}
+			const attribute = attributes.get(name);
+			if (attribute) {
+				this._write(attribute.prop, coerceAttribute(value, attribute));
+				return;
+			}
+			const property = own.get(name);
+			if (property !== void 0) this._mark(property);
+		}
+		_resume = () => {
+			this._deferred = false;
+			if (this.isConnected) this.connectedCallback();
+		};
+		/** A parsing document wins; under a waiting element, its queue; upgraded on registration, the registration's. */
+		_deferralOf() {
+			const owner = this.ownerDocument;
+			if (owner.readyState === "loading") return TDeferral.parsing(owner);
+			return TDeferral.above(this) ?? (isUpgradedOnRegistration(this) || isUnderUpgrade(this) ? TDeferral.registration : void 0);
+		}
+		_connect() {
+			const again = this._light.built;
+			this._connected = true;
+			if (!again) {
+				this._readAttributes();
+				this._build();
+			}
+			this._assemble();
+			this._above = followAbove(this, this._onAbove);
+			if (again) TTeleport.recall(this);
+			this._flush(true);
+		}
+		_onAbove = () => {
+			this._hide(this.state);
+		};
+		/** With the polyfill, attribute callbacks come after the connection: the base doesn't wait for them. */
+		_readAttributes() {
+			for (const [name, attribute] of attributes) {
+				if (this._props.isGiven(attribute.prop) || !this.hasAttribute(name)) continue;
+				const raw = this.getAttribute(name);
+				this._write(attribute.prop, name === ID ? idOf(raw) : coerceAttribute(raw, attribute));
+			}
+		}
+		_write(name, value) {
+			this._props.write(name, value, this._binding);
+		}
+		_assemble() {
+			const props = this._props.open(this._root.localName);
+			const binding = spec.setup(this, this._ctrl, props, this._onUpdate);
+			this._binding = binding;
+			this._ctrl = binding.ctrl;
+			this._props.close(binding);
+		}
+		_build() {
+			const groups = this._light.gather();
+			const parts = spec.template.create(this, this._view);
+			if (fieldId) this._takeFieldId();
+			if (plan.wrapped) this._root = built(parts.root, "обёртку");
+			const field = this._receiverOf(parts);
+			if (field) {
+				this._handOver(field);
+				if (plan.control) TElementAttributes.of(this).bindField(field);
+			}
+			if (plan.outerIsRoot) this._outer = this._root;
+			this._teleport = this._teleportOf(parts.companion);
+			this._light.distribute(groups, parts.slots);
+		}
+		/** Who gets the markup's statics: the root's field or the root inside the wrapper. */
+		_receiverOf(parts) {
+			if (plan.wrapped) return this._root;
+			if (plan.control) return built(parts.control, "поле");
+		}
+		/** The field's `id` goes from the root to the prop; an empty one removes it, like a native `id`. */
+		_takeFieldId() {
+			const id = this.getAttribute(ID);
+			if (id === null) return;
+			this._write(ID, idOf(id));
+			this.removeAttribute(ID);
+		}
+		/** The removal calls no callbacks: the element observes none of these attributes. */
+		_handOver(target) {
+			for (const name of this.getAttributeNames()) {
+				if (plan.keep.has(name) || attributes.has(name) || own.has(name)) continue;
+				target.setAttribute(name, this.getAttribute(name) ?? "");
+				this.removeAttribute(name);
+			}
+		}
+		_teleportOf(companion) {
+			if (plan.layer === void 0) {
+				if (companion) throw new Error("[soxa] Шаблон построил спутник корня, а описание корня слоя не объявляет");
+				return;
+			}
+			this._companion = companion ?? null;
+			return new TTeleport(this, this._root, this._companion);
+		}
+		_onUpdate = (name, value) => {
+			this._props.remember(name, value);
+			this._mark(name);
+		};
+		/** No flush without a connection: the name waits for the full paint of the next one. */
+		_mark(name) {
+			this._dirty.add(name);
+			this._queueFlush();
+		}
+		_queueFlush() {
+			if (this._flushQueued || !this._connected) return;
+			this._flushQueued = true;
+			queueMicrotask(() => {
+				this._flushQueued = false;
+				if (this._connected) this._flush();
+			});
+		}
+		_viewOf() {
+			const light = this._light;
+			const state = () => this._binding?.state ?? {};
+			const instance = () => this.ctrl;
+			const facade = () => this._binding?.facade;
+			return {
+				root: this,
+				get content() {
+					return light.content;
+				},
+				get state() {
+					return state();
+				},
+				get ctrl() {
+					return instance();
+				},
+				get facade() {
+					return facade();
+				},
+				hasSlot: (name) => light.has(name),
+				slotted: (name) => light.slotted(name),
+				showSlot: (name, shown) => light.show(name, shown),
+				sample: (name) => light.sample(name)
+			};
+		}
+		_flush(full = false) {
+			const state = this.state;
+			const paint = TPaint.of(this._root);
+			const dirty = new Set(this._dirty);
+			const changed = (name) => full || dirty.has(name);
+			this._dirty.clear();
+			if (changed("classes")) paint.classes("own", classesOf(state["classes"]));
+			for (const [layer, output] of plan.sets) if (changed(output)) TElementAttributes.of(this._root).set(layer, setOf(state[output]), inputs);
+			if (changed("layout_styles") || plan.style !== void 0 && changed(plan.style) || plan.order && changed("order")) paint.styles("own", stylesOf(state["layout_styles"], plan.style === void 0 ? void 0 : state[plan.style], plan.order ? orderOf(state["order"]) : void 0));
+			const layer = plan.layer;
+			const teleport = this._teleport;
+			const placing = layer !== void 0 && teleport !== void 0 && (full || changed(layer.target) || layer.contained !== void 0 && changed(layer.contained));
+			if (placing) this._placed = teleport.place(placeOf(state, layer));
+			if (changed("rendered") || changed("visible") || placing || plan.shownBy !== void 0 && changed(plan.shownBy)) this._hide(state);
+			for (const binding of spec.template.bindings) if (full || binding.props.some(changed)) binding.apply(this._view);
+		}
+		/** Hiding, the node for plugins and the own flag; the node goes on every call, the plugin skips the same one. */
+		_hide(state) {
+			const { hidden, present, subtree } = presenceOf(plan, state, this._above?.present ?? true, this._placed);
+			TPaint.of(this._outer).hidden(hidden);
+			if (this._companion) TPaint.of(this._companion).hidden(hidden);
+			this._binding?.bindElement(present ? this._root : null);
+			this._subtree.present = subtree;
+		}
+		/**
+		* Prop properties of all descriptors, except `ctrl`, `HOST_PROPS` and the
+		* tag's properties: a button's `disabled` stays native and reaches the core
+		* as an attribute. Then the properties of own attributes; a taken name is an
+		* error of the spec.
+		*/
+		static {
+			const props = new Set(descriptors.flatMap((descriptor) => Object.keys(TSurface.of(descriptor, WebcProfile).exportProps)));
+			for (const prop of props) {
+				if (prop === "ctrl" || isHostProp(prop) || prop in Native.prototype) continue;
+				Object.defineProperty(this.prototype, prop, {
+					configurable: true,
+					enumerable: true,
+					get() {
+						return this._props.read(prop, this._binding);
+					},
+					set(value) {
+						this._write(prop, value);
+					}
+				});
+			}
+			for (const [attribute, property] of own) {
+				if (attributes.has(attribute) || isHostProp(property) || property in this.prototype) throw new Error(`[soxa] Свой атрибут «${attribute}» занят: это имя уже у пропа, класса элемента или нативного элемента`);
+				Object.defineProperty(this.prototype, property, {
+					configurable: true,
+					enumerable: true,
+					get() {
+						return this.getAttribute(attribute);
+					},
+					set(value) {
+						if (value === null || value === void 0) this.removeAttribute(attribute);
+						else this.setAttribute(attribute, String(value));
+					}
+				});
+			}
+		}
+	}
+	return TElementBase;
+}
+//#endregion
+export { ElementBase };

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

@@ -0,0 +1,4 @@
+export { useAdapter, useCollectionAdapter, joinBindings, type TBinding, type TBindingState, type TCollectionBinding, type TUpdateListener, } from './useAdapter';
+export { ElementBase, type IElementBase, type IElementSpec, type TDescriptorFactory, type TElementClass, type TElementClassOf, type TElementOf, type TElementProps, type TElementType, type TOwnAttributes, type TNativeElementClass, } from './element.base';
+export type { TRootSet, TRootSpec, TRootTeleport } from './root';
+export { defineElement } from './defineElement';

package/dist/adapter/runtime/index.js

@@ -0,0 +1,4 @@
+import { defineElement } from "./defineElement.js";
+import { joinBindings, useAdapter, useCollectionAdapter } from "./useAdapter.js";
+import { ElementBase } from "./element.base.js";
+export { ElementBase, defineElement, joinBindings, useAdapter, useCollectionAdapter };

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

@@ -0,0 +1,33 @@
+/**
+ * Свет элемента — его содержимое из разметки, разложенное по точкам шаблона.
+ * Shadow DOM нет: тема — глобальные классы, и через теневую границу они не
+ * проходят. Слот — по атрибуту `slot` (назначенный шаблоном владельца
+ * главнее), слот без содержимого не задан, слот, которого шаблон не объявил,
+ * не выводится. Раскладывается один раз, переносом силами базы. AGENTS.md
+ * (Web Components), «Свет и слоты».
+ */
+import type { TSlotTargets } from '../template';
+export declare class TLight {
+    private readonly _host;
+    /** Заданные слоты; `null` — структура ещё не построена. */
+    private _slots;
+    private _targets;
+    /** Слоты, которые привязка сняла: их содержимое вне документа. */
+    private readonly _hidden;
+    private _content;
+    constructor(_host: HTMLElement);
+    get built(): boolean;
+    /** Узел слота по умолчанию; его нет (ProgressSpinner) — сам элемент. */
+    get content(): HTMLElement;
+    has(name: string): boolean;
+    /** Свет по слотам — до построения шаблона: обёртку слота он строит, только когда она нужна. */
+    gather(): ReadonlyMap<string, ChildNode[]>;
+    /** По точкам в порядке их объявления; образец уходит из документа, лишнее снимается. */
+    distribute(groups: ReadonlyMap<string, ChildNode[]>, targets: TSlotTargets): void;
+    /** Слот, который выводит привязка (`showSlot`): снятое уходит из документа. */
+    show(name: string, shown: boolean): void;
+    /** Узлы слота в его точке — копией списка; образец — пусто. */
+    slotted(name: string): readonly ChildNode[];
+    /** Новая копия образца на каждый вызов. */
+    sample(name: string): DocumentFragment | null;
+}