@pgcorp/ui-kit 0.10.0 → 0.10.1

package/dist/src/components/shared/controls/SDropdownMenu.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,128 @@
+import { useUiKitLocale as e } from "../../../composables/useUiKitLocale.js";
+import { useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import n from "./SButton.vue.js";
+import { useMenuLayer as r } from "../../../internal/useMenuLayer.js";
+import i from "../_internal/SMenuLayer.vue.js";
+import { validateSMenuEntries as a } from "./menu.js";
+import o from "./SMenuSurface.vue.js";
+import { Teleport as s, computed as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createVNode as f, defineComponent as p, mergeProps as m, nextTick as h, onMounted as g, openBlock as _, ref as v, renderSlot as y, unref as b, useId as x, useSlots as S, watchEffect as C, withCtx as w } from "vue";
+//#region src/components/shared/controls/SDropdownMenu.vue?vue&type=script&setup=true&lang.ts
+var T = { class: "s-dropdown-menu" }, E = /*@__PURE__*/ p({
+	inheritAttrs: !1,
+	__name: "SDropdownMenu",
+	props: {
+		items: {},
+		align: { default: "right" },
+		menuLabel: { default: void 0 }
+	},
+	emits: ["select"],
+	setup(p, { emit: E }) {
+		let D = p, { t: O } = e(), k = c(() => D.menuLabel ?? O("dialog.moreActions")), A = E, j = S(), M = t({
+			component: "SDropdownMenu",
+			owner: "menu trigger"
+		}), N = v(null), P = v(null), F = null, I = c(() => N.value?.getElement() ?? null), { isOpen: L, position: R, zIndex: z, close: B, closeForTab: V, open: H, toggle: U } = r(I), W = `s-dropdown-menu-${x()}`, G = v("first"), K = !!j.default;
+		function q(e) {
+			if (e === null) return null;
+			if (e instanceof HTMLElement) return e;
+			let t = Reflect.get(e, "getElement");
+			if (typeof t != "function") throw Error("SDropdownMenu: trigger ref must resolve to an HTMLElement or UI-kit leaf API");
+			let n = Reflect.apply(t, e, []);
+			if (!(n instanceof HTMLElement)) throw Error("SDropdownMenu: trigger leaf getElement() must return an HTMLElement");
+			return n;
+		}
+		let J = (e) => {
+			if (e !== null && F !== null && e !== F) throw Error("SDropdownMenu: trigger binding must belong to exactly one UI-kit leaf");
+			F = e;
+		}, Y = () => {
+			let e = M.bindings();
+			if (Object.prototype.hasOwnProperty.call(e, "onClick")) throw Error("SDropdownMenu: @click belongs to the typed triggerAttrs activation contract");
+			return {
+				...e,
+				ref: J,
+				"aria-haspopup": "menu",
+				"aria-expanded": L.value,
+				"aria-controls": W,
+				onClick: Z,
+				onKeydown: Q
+			};
+		};
+		function X(e) {
+			let t = q(F);
+			if (!t) throw Error("SDropdownMenu: expected exactly one trigger, received 0");
+			if (e?.currentTarget instanceof HTMLElement && e.currentTarget !== t) throw Error("SDropdownMenu: activation target does not match the registered trigger");
+			return t;
+		}
+		g(() => {
+			let e = X();
+			if (e.getAttribute("aria-haspopup") !== "menu" || e.getAttribute("aria-controls") !== W) throw Error("SDropdownMenu: expected exactly one trigger, received 0");
+		});
+		function Z(e) {
+			let t = X(e);
+			G.value = "first", U({
+				type: "element",
+				element: t,
+				align: D.align
+			}, t);
+		}
+		async function Q(e) {
+			if (e.key !== "ArrowDown" && e.key !== "ArrowUp") return;
+			e.preventDefault(), e.stopPropagation();
+			let t = X(e);
+			G.value = e.key === "ArrowUp" ? "last" : "first", L.value || await H({
+				type: "element",
+				element: t,
+				align: D.align
+			}, t), await h(), G.value === "last" ? P.value?.focusLast() : P.value?.focusFirst();
+		}
+		function $(e, t) {
+			e.disabled || (B("selection"), A("select", e, t));
+		}
+		return C(() => {
+			if (a(D.items), !k.value.trim()) throw TypeError("SDropdownMenu: menuLabel must be a non-empty string");
+			if (D.align !== "left" && D.align !== "right") throw TypeError("SDropdownMenu: align must be 'left' or 'right'");
+		}), (e, t) => (_(), d("div", T, [b(K) ? y(e.$slots, "default", { triggerAttrs: Y() }, void 0, !0, 0) : (_(), l(n, m({ key: 1 }, Y(), {
+			label: "Опции",
+			disclosure: {
+				expanded: b(L),
+				controls: W
+			},
+			severity: "secondary"
+		}), null, 16, ["disclosure"])), (_(), l(s, { to: "body" }, [b(L) ? (_(), l(i, {
+			key: 0,
+			ref_key: "layerRef",
+			ref: N,
+			kind: "dropdown",
+			"landmark-label": k.value,
+			position: b(R),
+			"z-index": b(z)
+		}, {
+			default: w(() => [f(o, {
+				ref_key: "menuSurfaceRef",
+				ref: P,
+				id: W,
+				label: k.value,
+				density: "compact",
+				autofocus: "",
+				"initial-focus": G.value,
+				items: p.items,
+				onDismissTree: t[0] ||= (e) => b(B)("outside"),
+				onEscape: t[1] ||= (e) => b(B)("escape"),
+				onFocusExit: t[2] ||= (e) => b(B)("outside"),
+				onSelect: $,
+				onTab: b(V)
+			}, null, 8, [
+				"label",
+				"initial-focus",
+				"items",
+				"onTab"
+			])]),
+			_: 1
+		}, 8, [
+			"landmark-label",
+			"position",
+			"z-index"
+		])) : u("", !0)]))]));
+	}
+});
+//#endregion
+export { E as default };

package/dist/src/components/shared/controls/SField.vue.d.ts

@@ -0,0 +1,53 @@
+/** Расположение подписи относительно control-region. / Label placement relative to the control region. */
+export type SFieldLayout = 'stacked' | 'inline';
+/** Высота field-root и его control-region. / Height contract for the field root and control region. */
+export type SFieldFill = 'content' | 'container';
+export interface Props {
+    controlId: string;
+    label?: string;
+    required?: boolean;
+    helpText?: string;
+    errorMessage?: string;
+    invalid?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    layout?: SFieldLayout;
+    fill?: SFieldFill;
+}
+declare var __VLS_1: {}, __VLS_3: {
+    controlId: string;
+    labelledBy: string | undefined;
+    describedBy: string | undefined;
+    invalid: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+}, __VLS_5: {}, __VLS_7: {};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+} & {
+    help?: (props: typeof __VLS_5) => any;
+} & {
+    error?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    layout: SFieldLayout;
+    required: boolean;
+    fill: SFieldFill;
+    label: string;
+    invalid: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    helpText: string;
+    errorMessage: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/shared/controls/SField.vue.js

@@ -0,0 +1,8 @@
+import "../../../../assets/src/components/shared/controls/SField.css_vue_type_style_index_0_src_60628f96_scoped_60628f96_lang.css";
+import e from "../../../../_virtual/_plugin-vue_export-helper.js";
+import t from "./SField.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                    */
+//#region src/components/shared/controls/SField.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-60628f96"]]);
+//#endregion
+export { n as default };

package/dist/src/components/shared/controls/SField.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,86 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { FIELD_ERROR_CLASS as t, FIELD_HELP_CLASS as n, FIELD_REQUIRED_CLASS as r, useFieldSupportingText as i } from "../../../internal/fieldPresentation.js";
+import { computed as a, createCommentVNode as o, createElementBlock as s, createElementVNode as c, createTextVNode as l, defineComponent as u, mergeProps as d, normalizeClass as f, openBlock as p, renderSlot as m, toDisplayString as h, unref as g, useSlots as _ } from "vue";
+//#region src/components/shared/controls/SField.vue?vue&type=script&setup=true&lang.ts
+var v = [
+	"data-disabled",
+	"data-readonly",
+	"data-invalid",
+	"data-fill"
+], y = ["id", "for"], b = { class: "s-field__control" }, x = ["id"], S = ["id"], C = /*@__PURE__*/ u({
+	inheritAttrs: !1,
+	__name: "SField",
+	props: {
+		controlId: {},
+		label: { default: void 0 },
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		helpText: { default: void 0 },
+		errorMessage: { default: void 0 },
+		invalid: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		layout: { default: "stacked" },
+		fill: { default: "content" }
+	},
+	setup(u) {
+		let C = u, w = _(), T = e({
+			component: "SField",
+			owner: "field root"
+		}), E = a(() => C.invalid), D = a(() => !!(C.label || w.label)), O = a(() => `${C.controlId}-label`), k = a(() => C.controlId), { describedBy: A, errorId: j, helpId: M } = i({
+			baseId: k,
+			hasHelp: () => !!(C.helpText || w.help),
+			hasError: () => !!(E.value && (C.errorMessage || w.error))
+		});
+		return (e, i) => (p(), s("div", d(g(T).bindings(), {
+			class: ["s-field", `s-field--${u.layout}`],
+			"data-disabled": u.disabled || void 0,
+			"data-readonly": u.readonly || void 0,
+			"data-invalid": E.value || void 0,
+			"data-fill": u.fill
+		}), [
+			D.value ? (p(), s("label", {
+				key: 0,
+				id: O.value,
+				class: "s-field__label",
+				for: u.controlId
+			}, [m(e.$slots, "label", {}, () => [l(h(u.label), 1)], !0), u.required ? (p(), s("span", {
+				key: 0,
+				class: f(["s-field__required", g(r)]),
+				"aria-hidden": "true"
+			}, "*", 2)) : o("", !0)], 8, y)) : o("", !0),
+			c("div", b, [m(e.$slots, "default", {
+				controlId: u.controlId,
+				labelledBy: D.value ? O.value : void 0,
+				describedBy: g(A),
+				invalid: E.value,
+				disabled: u.disabled,
+				readonly: u.readonly,
+				required: u.required
+			}, void 0, !0)]),
+			u.helpText || e.$slots.help ? (p(), s("p", {
+				key: 1,
+				id: g(M),
+				class: f(["s-field__help", g(n)])
+			}, [m(e.$slots, "help", {}, () => [l(h(u.helpText), 1)], !0)], 10, x)) : o("", !0),
+			E.value && (u.errorMessage || e.$slots.error) ? (p(), s("p", {
+				key: 2,
+				id: g(j),
+				class: f(["s-field__error", g(t)])
+			}, [m(e.$slots, "error", {}, () => [l(h(u.errorMessage), 1)], !0)], 10, S)) : o("", !0)
+		], 16, v));
+	}
+});
+//#endregion
+export { C as default };

package/dist/src/components/shared/controls/SFieldGroup.vue.d.ts

@@ -0,0 +1,53 @@
+/** Раскладка controls внутри семантической группы. / Controls layout inside a semantic group. */
+export type SFieldGroupLayout = 'stacked' | 'inline' | 'grid';
+/** Число semantic grid columns без raw CSS length. / Semantic grid column count without a raw CSS length. */
+export type SFieldGroupColumns = 1 | 2 | 3 | 4;
+export interface Props {
+    label: string;
+    id?: string;
+    helpText?: string;
+    errorMessage?: string;
+    required?: boolean;
+    invalid?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    layout?: SFieldGroupLayout;
+    columns?: SFieldGroupColumns;
+}
+declare var __VLS_1: {}, __VLS_3: {
+    groupId: string;
+    labelId: string;
+    describedBy: string | undefined;
+    invalid: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+}, __VLS_5: {}, __VLS_7: {};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+} & {
+    help?: (props: typeof __VLS_5) => any;
+} & {
+    error?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    layout: SFieldGroupLayout;
+    required: boolean;
+    id: string;
+    columns: SFieldGroupColumns;
+    invalid: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    helpText: string;
+    errorMessage: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/shared/controls/SFieldGroup.vue.js

@@ -0,0 +1,8 @@
+import "../../../../assets/src/components/shared/controls/SFieldGroup.css_vue_type_style_index_0_src_fc781c88_scoped_fc781c88_lang.css";
+import e from "../../../../_virtual/_plugin-vue_export-helper.js";
+import t from "./SFieldGroup.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                         */
+//#region src/components/shared/controls/SFieldGroup.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-fc781c88"]]);
+//#endregion
+export { n as default };

package/dist/src/components/shared/controls/SFieldGroup.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,102 @@
+import { mergeIdReferences as e, useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { validateBoundedInteger as n, validateDomId as r, validateExactString as i, validateNonEmptyString as a } from "../../../internal/runtimeContract.js";
+import { FIELD_ERROR_CLASS as o, FIELD_HELP_CLASS as s, FIELD_REQUIRED_CLASS as c, useFieldSupportingText as l } from "../../../internal/fieldPresentation.js";
+import { computed as u, createCommentVNode as d, createElementBlock as f, createElementVNode as p, createTextVNode as m, defineComponent as h, mergeProps as g, normalizeClass as _, openBlock as v, renderSlot as y, toDisplayString as b, unref as x, useId as S, useSlots as C } from "vue";
+//#region src/components/shared/controls/SFieldGroup.vue?vue&type=script&setup=true&lang.ts
+var w = [
+	"id",
+	"disabled",
+	"aria-describedby",
+	"aria-invalid",
+	"data-disabled",
+	"data-readonly",
+	"data-invalid",
+	"data-layout",
+	"data-columns"
+], T = ["id"], E = { class: "s-field-group__controls" }, D = ["id"], O = ["id"], k = /*@__PURE__*/ h({
+	inheritAttrs: !1,
+	__name: "SFieldGroup",
+	props: {
+		label: {},
+		id: { default: void 0 },
+		helpText: { default: void 0 },
+		errorMessage: { default: void 0 },
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		invalid: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		layout: { default: "stacked" },
+		columns: { default: 1 }
+	},
+	setup(h) {
+		let k = [
+			"stacked",
+			"inline",
+			"grid"
+		], A = {
+			minimum: 1,
+			maximum: 4
+		}, j = h, M = C(), N = t({
+			component: "SFieldGroup",
+			owner: "native fieldset"
+		}), P = S(), F = u(() => r("SFieldGroup", "id", j.id ?? `s-field-group-${P}`)), I = u(() => `${F.value}-legend`), L = u(() => a("SFieldGroup", "label", j.label)), { describedBy: R, errorId: z, helpId: B } = l({
+			baseId: F,
+			hasHelp: () => !!(j.helpText || M.help),
+			hasError: () => !!(j.invalid && (j.errorMessage || M.error))
+		}), V = u(() => i("SFieldGroup", "layout", j.layout, k)), H = u(() => n("SFieldGroup", "columns", j.columns, A));
+		return (t, n) => (v(), f("fieldset", g(x(N).bindings(), {
+			id: F.value,
+			class: "s-field-group",
+			disabled: h.disabled,
+			"aria-describedby": x(e)(x(N).string("aria-describedby"), x(R)),
+			"aria-invalid": h.invalid || void 0,
+			"data-disabled": h.disabled || void 0,
+			"data-readonly": h.readonly || void 0,
+			"data-invalid": h.invalid || void 0,
+			"data-layout": V.value,
+			"data-columns": V.value === "grid" ? H.value : void 0
+		}), [
+			p("legend", {
+				id: I.value,
+				class: "s-field-group__legend"
+			}, [y(t.$slots, "label", {}, () => [m(b(L.value), 1)], !0), h.required ? (v(), f("span", {
+				key: 0,
+				class: _(["s-field-group__required", x(c)]),
+				"aria-hidden": "true"
+			}, "*", 2)) : d("", !0)], 8, T),
+			p("div", E, [y(t.$slots, "default", {
+				groupId: F.value,
+				labelId: I.value,
+				describedBy: x(R),
+				invalid: h.invalid,
+				disabled: h.disabled,
+				readonly: h.readonly,
+				required: h.required
+			}, void 0, !0)]),
+			h.helpText || t.$slots.help ? (v(), f("p", {
+				key: 0,
+				id: x(B),
+				class: _(["s-field-group__help", x(s)])
+			}, [y(t.$slots, "help", {}, () => [m(b(h.helpText), 1)], !0)], 10, D)) : d("", !0),
+			h.invalid && (h.errorMessage || t.$slots.error) ? (v(), f("p", {
+				key: 1,
+				id: x(z),
+				class: _(["s-field-group__error", x(o)])
+			}, [y(t.$slots, "error", {}, () => [m(b(h.errorMessage), 1)], !0)], 10, O)) : d("", !0)
+		], 16, w));
+	}
+});
+//#endregion
+export { k as default };

package/dist/src/components/shared/controls/SFieldLabel.vue.d.ts

@@ -0,0 +1,35 @@
+import { VNodeChild } from 'vue';
+/**
+ * Standalone label-owner для композиций с раздельными grid-регионами подписи и control.
+ * Standalone label owner for compositions with separate label and control grid regions.
+ */
+export interface Props {
+    /** ID связанного control. / ID of the associated control. */
+    forId?: string;
+    /** Выравнивание текста внутри label-region. / Text alignment within the label region. */
+    align?: 'start' | 'end';
+    /** Семантический размер типографики. / Semantic typography size. */
+    size?: 'sm' | 'md';
+    /** Показывает обязательность без замены native required control contract. / Shows required presentation without replacing the native control contract. */
+    required?: boolean;
+    /** Приглушает подпись связанного disabled control. / Mutes the label of an associated disabled control. */
+    disabled?: boolean;
+}
+type __VLS_Slots = {
+    default?: () => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    required: boolean;
+    size: "sm" | "md";
+    disabled: boolean;
+    align: "start" | "end";
+    forId: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/shared/controls/SFieldLabel.vue.js

@@ -0,0 +1,8 @@
+import "../../../../assets/src/components/shared/controls/SFieldLabel.css_vue_type_style_index_0_src_80025f86_scoped_80025f86_lang.css";
+import e from "../../../../_virtual/_plugin-vue_export-helper.js";
+import t from "./SFieldLabel.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                         */
+//#region src/components/shared/controls/SFieldLabel.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-80025f86"]]);
+//#endregion
+export { n as default };

package/dist/src/components/shared/controls/SFieldLabel.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,45 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { FIELD_REQUIRED_CLASS as t } from "../../../internal/fieldPresentation.js";
+import { createCommentVNode as n, createElementBlock as r, defineComponent as i, mergeProps as a, normalizeClass as o, openBlock as s, renderSlot as c, unref as l } from "vue";
+//#region src/components/shared/controls/SFieldLabel.vue?vue&type=script&setup=true&lang.ts
+var u = [
+	"for",
+	"data-align",
+	"data-size",
+	"data-disabled"
+], d = /*@__PURE__*/ i({
+	inheritAttrs: !1,
+	__name: "SFieldLabel",
+	props: {
+		forId: { default: void 0 },
+		align: { default: "start" },
+		size: { default: "md" },
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	setup(i) {
+		let d = e({
+			component: "SFieldLabel",
+			owner: "native label"
+		});
+		return (e, f) => (s(), r("label", a(l(d).bindings(), {
+			class: "s-field-label",
+			for: i.forId,
+			"data-align": i.align,
+			"data-size": i.size,
+			"data-disabled": i.disabled || void 0
+		}), [c(e.$slots, "default", {}, void 0, !0), i.required ? (s(), r("span", {
+			key: 0,
+			class: o(["s-field-label__required", l(t)]),
+			"aria-hidden": "true"
+		}, "*", 2)) : n("", !0)], 16, u));
+	}
+});
+//#endregion
+export { d as default };

package/dist/src/components/shared/controls/SInlineTokenEditor.vue.d.ts

@@ -0,0 +1,80 @@
+import { InlineTokenEditorSegmentContract } from '../../../internal/inlineTokenEditorContract';
+/** Canonical text/token segment без nullable/fallback states. / Canonical text/token segment without nullable or fallback states. */
+export type SInlineTokenEditorSegment = InlineTokenEditorSegmentContract;
+/** Public editor contract с exact model mirror и semantic row sizing. / Public editor contract with an exact model mirror and semantic row sizing. */
+export interface Props {
+    modelValue: string;
+    segments: readonly SInlineTokenEditorSegment[];
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    errorMessage?: string;
+    helpText?: string;
+    id?: string;
+    rows?: number;
+    maxRows?: number;
+    appearance?: 'default' | 'ghost';
+}
+/** Exact text/cursor state after a user or imperative edit. / Exact text/cursor state после user или imperative edit. */
+export interface SInlineTokenEditorState {
+    text: string;
+    cursor: number;
+}
+/** Exact identity of one token occurrence and its domain entity. / Точная identity одного вхождения токена и его доменной сущности. */
+export interface SInlineTokenEditorTokenReference {
+    occurrenceId: string;
+    id: string;
+}
+/** Atomic controlled replacement request with one cursor commit. / Атомарный запрос controlled-замены с единым commit курсора. */
+export interface SInlineTokenEditorReplacement {
+    start: number;
+    end: number;
+    segments: readonly SInlineTokenEditorSegment[];
+    cursor: number;
+}
+/** Public imperative surface for focus, selection, and atomic domain insertions. / Публичная imperative-поверхность focus, selection и атомарных доменных вставок. */
+export interface SInlineTokenEditorApi {
+    focus: () => void;
+    insertSoftLineBreak: () => void;
+    getSelectionOffset: () => number;
+    queueSelectionOffset: (offset: number) => void;
+    setSelectionOffset: (offset: number) => void;
+    replaceRange: (replacement: SInlineTokenEditorReplacement) => void;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, SInlineTokenEditorApi, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (event: MouseEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    keyup: (event: KeyboardEvent) => any;
+    "update:modelValue": (value: string) => any;
+    "state-change": (state: SInlineTokenEditorState) => any;
+    "update:segments": (value: InlineTokenEditorSegmentContract[]) => any;
+    "open-token": (token: SInlineTokenEditorTokenReference) => any;
+    "remove-token": (token: SInlineTokenEditorTokenReference) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onState-change"?: ((state: SInlineTokenEditorState) => any) | undefined;
+    "onUpdate:segments"?: ((value: InlineTokenEditorSegmentContract[]) => any) | undefined;
+    "onOpen-token"?: ((token: SInlineTokenEditorTokenReference) => any) | undefined;
+    "onRemove-token"?: ((token: SInlineTokenEditorTokenReference) => any) | undefined;
+}>, {
+    required: boolean;
+    label: string;
+    id: string;
+    invalid: boolean;
+    placeholder: string;
+    disabled: boolean;
+    readonly: boolean;
+    rows: number;
+    helpText: string;
+    errorMessage: string;
+    appearance: "default" | "ghost";
+    maxRows: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/shared/controls/SInlineTokenEditor.vue.js

@@ -0,0 +1,5 @@
+import e from "./SInlineTokenEditor.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/shared/controls/SInlineTokenEditor.vue
+var t = e;
+//#endregion
+export { t as default };