@pgcorp/ui-kit 0.10.0 → 0.10.2

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

@@ -0,0 +1,553 @@
+import { mergeIdReferences as e, useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { validateBoolean as n, validateBoundedInteger as r, validateDomId as i, validateExactString as a, validateNonEmptyString as o } from "../../../internal/runtimeContract.js";
+import s from "./SField.vue.js";
+import { resolveFieldSurfaceBindings as c } from "../../../internal/fieldSurface.js";
+import { composeInlineTokenSegments as l, inlineTokenSegmentsToText as ee, parseInlineTokenEditorSource as u, validateInlineTokenCursorBoundary as d } from "../../../internal/inlineTokenEditorContract.js";
+import te from "./_internal/SInlineTokenSurface.vue.js";
+import { computed as f, createBlock as ne, createVNode as re, defineComponent as p, openBlock as ie, ref as m, unref as h, useId as ae, watch as g, withCtx as oe } from "vue";
+//#region src/components/shared/controls/SInlineTokenEditor.vue?vue&type=script&setup=true&lang.ts
+var _ = /*@__PURE__*/ p({
+	inheritAttrs: !1,
+	__name: "SInlineTokenEditor",
+	props: {
+		modelValue: {},
+		segments: {},
+		label: { default: void 0 },
+		placeholder: { default: void 0 },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		invalid: {
+			type: Boolean,
+			default: !1
+		},
+		errorMessage: { default: void 0 },
+		helpText: { default: void 0 },
+		id: { default: void 0 },
+		rows: { default: 3 },
+		maxRows: { default: 0 },
+		appearance: { default: "default" }
+	},
+	emits: [
+		"update:modelValue",
+		"update:segments",
+		"keydown",
+		"keyup",
+		"click",
+		"open-token",
+		"remove-token",
+		"state-change"
+	],
+	setup(p, { expose: _, emit: se }) {
+		let v = p, y = se, b = t({
+			component: "SInlineTokenEditor",
+			owner: "inline token editing surface"
+		}), ce = ae(), x = f(() => v.id === void 0 ? `s-inline-token-editor-${ce}` : i("SInlineTokenEditor", "id", v.id)), S = m(null), le = (e) => {
+			if (e !== null && !(e instanceof HTMLDivElement)) throw TypeError("SInlineTokenEditor: editing surface ref должен быть HTMLDivElement. / SInlineTokenEditor: editing surface ref must be an HTMLDivElement.");
+			S.value = e;
+		}, C = m(0), w = m(null), T = m(null), E = f(() => u(v.modelValue, v.segments)), D = f(() => n("SInlineTokenEditor", "disabled", v.disabled)), O = f(() => n("SInlineTokenEditor", "readonly", v.readonly)), ue = f(() => n("SInlineTokenEditor", "required", v.required)), de = f(() => n("SInlineTokenEditor", "invalid", v.invalid)), k = f(() => a("SInlineTokenEditor", "appearance", v.appearance, ["default", "ghost"])), fe = f(() => E.value.length > 0), pe = f(() => !fe.value), A = f(() => M(E.value).endsWith("\n") ? "newline" : E.value[E.value.length - 1]?.kind === "token" ? "token" : null), j = f(() => A.value !== null), me = f(() => JSON.stringify({
+			segments: E.value,
+			trailingCaretHelperKind: A.value,
+			tokenRemovalDisabled: D.value || O.value
+		}));
+		function he(e) {
+			return c("SInlineTokenEditor", {
+				kind: "inline-token-editor",
+				appearance: k.value === "default" ? "field" : "ghost",
+				invalid: e.invalid,
+				disabled: e.disabled,
+				readonly: e.readonly
+			});
+		}
+		let M = (e) => ee(e), N = (e) => e.nodeType === Node.TEXT_NODE && e.textContent === "​", P = (e) => o("SInlineTokenEditor", "DOM token label", e.dataset.segmentLabel).length, F = (e, t) => {
+			let n = Array.from(e);
+			for (let e = n.length - 1; e >= 0; --e) {
+				let r = n[e];
+				if (r && t(r)) return r;
+			}
+			return null;
+		}, I = (e) => {
+			if (!e) return null;
+			if (e.nodeType === Node.TEXT_NODE) {
+				let t = e;
+				return N(t) ? null : t;
+			}
+			for (let t of Array.from(e.childNodes)) {
+				let e = I(t);
+				if (e) return e;
+			}
+			return null;
+		}, L = (e) => {
+			if (e.nodeType === Node.TEXT_NODE) return N(e) ? 0 : e.data.length;
+			if (e instanceof HTMLElement && e.dataset.segmentKind === "token") return P(e);
+			let t = 0;
+			return e.childNodes.forEach((e) => {
+				t += L(e);
+			}), t;
+		}, R = (e, t, n) => {
+			if (!Number.isInteger(t)) throw TypeError(`SInlineTokenEditor: ${n} должен быть целым DOM offset. / SInlineTokenEditor: ${n} must be an integer DOM offset.`);
+			let r = e.nodeType === Node.TEXT_NODE ? e.data.length : e.childNodes.length;
+			if (t < 0 || t > r) throw RangeError(`SInlineTokenEditor: ${n}=${t} вне DOM range [0, ${r}]. / SInlineTokenEditor: ${n}=${t} is outside DOM range [0, ${r}].`);
+			return t;
+		}, z = (e, t, n) => {
+			if (e === t) {
+				let r = R(t, n, "selection boundary");
+				if (e.nodeType === Node.TEXT_NODE) return N(e) ? 0 : r;
+				let i = 0, a = Array.from(e.childNodes);
+				for (let e = 0; e < r; e += 1) i += L(a[e]);
+				return i;
+			}
+			if (e.nodeType === Node.TEXT_NODE) return N(e) ? 0 : e.data.length;
+			if (e instanceof HTMLElement && e.dataset.segmentKind === "token") return P(e);
+			let r = 0;
+			for (let i of Array.from(e.childNodes)) {
+				if (i === t || i.contains(t)) return r += z(i, t, n), r;
+				r += L(i);
+			}
+			throw RangeError("SInlineTokenEditor: selection boundary не принадлежит editing surface. / SInlineTokenEditor: selection boundary does not belong to the editing surface.");
+		}, B = (e, t) => {
+			let n = S.value;
+			if (!n) throw Error("SInlineTokenEditor: editing surface не готова для getSelectionOffset. / SInlineTokenEditor: editing surface is not ready for getSelectionOffset.");
+			let r = window.getSelection();
+			if (!r) throw Error("SInlineTokenEditor: Selection API недоступен для getSelectionOffset. / SInlineTokenEditor: Selection API is unavailable for getSelectionOffset.");
+			if (r.rangeCount === 0) throw Error("SInlineTokenEditor: активная selection отсутствует для getSelectionOffset. / SInlineTokenEditor: no active selection exists for getSelectionOffset.");
+			let i = r.getRangeAt(0);
+			if (!n.contains(i.startContainer) && i.startContainer !== n) throw Error("SInlineTokenEditor: активная selection не принадлежит editing surface. / SInlineTokenEditor: the active selection does not belong to the editing surface.");
+			if (i.startContainer === n && n.childNodes.length === 0) return R(n, i.startOffset, "empty editor selection boundary"), C.value = 0, 0;
+			let a = d(e, z(n, i.startContainer, i.startOffset), t);
+			return C.value = a, a;
+		}, V = () => B(E.value, "active selection offset"), H = (e, t) => {
+			let n = document.createRange(), r = E.value, i = d(r, t, "selection offset"), a = i, o = M(r);
+			if (j.value && i === o.length) {
+				let t = F(e.childNodes, N);
+				if (t) return n.setStart(t, t.data.length), n.collapse(!0), n;
+			}
+			let s = (t) => {
+				if (t.nodeType === Node.TEXT_NODE) {
+					if (N(t)) return n.setStart(t, t.data.length), n.collapse(!0), !0;
+					let e = t.data.length;
+					if (a > e) throw RangeError(`SInlineTokenEditor: selection traversal overflow ${a} > ${e}.`);
+					return n.setStart(t, a), n.collapse(!0), !0;
+				}
+				if (t instanceof HTMLElement && t.dataset.segmentKind === "token") {
+					let r = P(t), i = t.parentNode;
+					if (!i) return !1;
+					let o = Array.from(i.childNodes), s = o.indexOf(t);
+					if (a === 0) return n.setStart(i, s), n.collapse(!0), !0;
+					if (a === r) {
+						let t = I(o[s + 1] ?? null);
+						if (t) return n.setStart(t, 0), n.collapse(!0), !0;
+						let r = F(e.childNodes, N);
+						return r ? (n.setStart(r, r.data.length), n.collapse(!0), !0) : (n.setStart(i, s + 1), n.collapse(!0), !0);
+					}
+					if (a < r) throw RangeError(`SInlineTokenEditor: selection offset ${a} попал внутрь atomic token ${JSON.stringify(t.dataset.segmentId)}. / SInlineTokenEditor: selection offset ${a} fell inside atomic token ${JSON.stringify(t.dataset.segmentId)}.`);
+					return a -= r, !1;
+				}
+				let r = Array.from(t.childNodes);
+				if (!r.length) return n.setStart(t, 0), n.collapse(!0), !0;
+				for (let e of r) {
+					let t = L(e);
+					if (a <= t) return s(e);
+					a -= t;
+				}
+				return n.setStart(t, r.length), n.collapse(!0), !0;
+			};
+			return s(e), n;
+		}, U = (e) => {
+			let t = S.value;
+			if (!t) throw Error("SInlineTokenEditor: editing surface не готова. / SInlineTokenEditor: editing surface is not ready.");
+			let n = window.getSelection();
+			if (!n) throw Error("SInlineTokenEditor: Selection API недоступен. / SInlineTokenEditor: Selection API is unavailable.");
+			let r = H(t, e);
+			n.removeAllRanges(), n.addRange(r), C.value = d(E.value, e, "placed selection offset");
+		}, W = (e) => {
+			y("state-change", {
+				text: e ?? M(E.value),
+				cursor: V()
+			});
+		}, G = () => {
+			let e = S.value;
+			if (!e) throw Error("SInlineTokenEditor: невозможно прочитать DOM до readiness. / SInlineTokenEditor: cannot read DOM before readiness.");
+			if (e.childNodes.length === 1 && e.firstChild instanceof HTMLBRElement) return [];
+			let t = [], n = (e) => {
+				if (!e) return;
+				let n = t[t.length - 1];
+				n?.kind === "text" ? t[t.length - 1] = {
+					kind: "text",
+					text: n.text + e
+				} : t.push({
+					kind: "text",
+					text: e
+				});
+			}, r = (e) => {
+				if (e.nodeType === Node.TEXT_NODE) {
+					if (N(e)) return;
+					n(e.data);
+					return;
+				}
+				if (e instanceof HTMLElement && e.dataset.segmentKind === "token") {
+					let n = {
+						kind: "token",
+						occurrenceId: e.dataset.segmentOccurrenceId,
+						id: e.dataset.segmentId,
+						label: e.dataset.segmentLabel,
+						...e.dataset.segmentTitle === void 0 ? {} : { title: e.dataset.segmentTitle }
+					}, r = u(n.label, [n])[0];
+					if (!r || r.kind !== "token") throw TypeError("SInlineTokenEditor: token DOM parser не создал token segment. / SInlineTokenEditor: token DOM parser did not produce a token segment.");
+					t.push(r);
+					return;
+				}
+				if (e.nodeType !== Node.COMMENT_NODE) throw TypeError(`SInlineTokenEditor: неожиданный DOM node ${e.nodeName} вне canonical text/token grammar. / SInlineTokenEditor: unexpected DOM node ${e.nodeName} outside the canonical text/token grammar.`);
+			};
+			return e.childNodes.forEach((e) => r(e)), t;
+		}, K = () => {
+			let e = G(), t = M(e);
+			u(t, e);
+			let n = B(e, "input selection offset");
+			C.value = n, w.value = n, y("update:segments", e), y("update:modelValue", t), y("state-change", {
+				text: t,
+				cursor: n
+			});
+		}, q = (e, t) => {
+			let n = l(e), r = M(n);
+			u(r, n);
+			let i = d(n, t, "committed cursor offset");
+			C.value = i, w.value = i, y("update:segments", n), y("update:modelValue", r), y("state-change", {
+				text: r,
+				cursor: i
+			});
+		}, J = () => {
+			let e = S.value;
+			return e ? F(e.childNodes, N) : null;
+		}, Y = (e) => {
+			let t = S.value, n = J();
+			if (!t || !n || !e.collapsed || !j.value) return !1;
+			if (e.startContainer === n) return !0;
+			if (e.startContainer !== t) return !1;
+			let r = Array.from(t.childNodes).indexOf(n);
+			return r >= 0 && e.startOffset === r + 1;
+		}, ge = () => {
+			let e = S.value, t = J();
+			if (!e || !t) return;
+			let n = Array.from(e.childNodes), r = n.indexOf(t), i = r > 0 ? n[r - 1] ?? null : null;
+			if (!(i instanceof Text) || i.textContent === null || !i.textContent.endsWith("\n")) throw Error("Trailing inline caret helper must follow a text node ending with newline.");
+			let a = i.textContent.slice(0, -1);
+			t.remove(), a.length === 0 ? i.remove() : i.textContent = a;
+			let o = window.getSelection();
+			if (o) {
+				let t = document.createRange();
+				t.selectNodeContents(e), t.collapse(!1), o.removeAllRanges(), o.addRange(t);
+			}
+			C.value = M(G()).length, K();
+		}, X = (e) => e.kind === "text" ? e.text.length : e.label.length, Z = (e, t) => {
+			let n = d(e, t, "split offset"), r = [], i = [], a = 0, o = !1;
+			for (let t of e) {
+				let e = X(t), s = a, c = a + e;
+				if (o || n <= s) {
+					i.push(t), a = c;
+					continue;
+				}
+				if (n >= c) {
+					r.push(t), a = c;
+					continue;
+				}
+				if (t.kind === "text") {
+					let e = n - s, a = t.text.slice(0, e), o = t.text.slice(e);
+					a && r.push({
+						kind: "text",
+						text: a
+					}), o && i.push({
+						kind: "text",
+						text: o
+					});
+				} else n > s ? r.push(t) : i.push(t);
+				o = !0, a = c;
+			}
+			return {
+				before: l(r),
+				after: l(i)
+			};
+		}, _e = (e, t, n) => {
+			let r = E.value, i = d(r, e, "replacement start"), a = d(r, t, "replacement end");
+			if (i > a) throw RangeError(`SInlineTokenEditor: replacement start ${i} не может быть больше end ${a}. / SInlineTokenEditor: replacement start ${i} cannot exceed end ${a}.`);
+			let o = Z(r, i), s = Z(r, a);
+			return l([
+				...o.before,
+				...n,
+				...s.after
+			]);
+		}, ve = (e) => {
+			let t = S.value;
+			if (!t) return null;
+			let n = M(E.value).length;
+			if (Y(e)) return {
+				start: n,
+				end: n
+			};
+			let r = (e, n) => e === t && t.childNodes.length === 0 ? (R(e, n, "empty editor selection boundary"), 0) : z(t, e, n);
+			return {
+				start: r(e.startContainer, e.startOffset),
+				end: r(e.endContainer, e.endOffset)
+			};
+		}, ye = (e) => {
+			let t = E.value, n = d(t, e, "delete backward offset");
+			if (n === 0) return;
+			let r = t.map((e) => e.kind === "text" ? {
+				kind: "text",
+				text: e.text
+			} : {
+				kind: "token",
+				occurrenceId: e.occurrenceId,
+				id: e.id,
+				label: e.label,
+				...e.title === void 0 ? {} : { title: e.title }
+			}), i = 0;
+			for (let e = 0; e < r.length; e += 1) {
+				let t = r[e], a = i + X(t);
+				if (n > a) {
+					i = a;
+					continue;
+				}
+				if (t.kind === "text") {
+					let a = n - i - 1;
+					if (a < 0 || a >= t.text.length) throw RangeError(`SInlineTokenEditor: delete index ${a} вне text segment [0, ${t.text.length - 1}]. / SInlineTokenEditor: delete index ${a} is outside text segment [0, ${t.text.length - 1}].`);
+					let o = `${t.text.slice(0, a)}${t.text.slice(a + 1)}`;
+					r[e] = {
+						kind: "text",
+						text: o
+					}, q(r, n - 1);
+					return;
+				}
+				let o = r[e - 1], s = r[e + 1];
+				o?.kind === "text" && s?.kind === "text" && o.text.endsWith(" ") && s.text.startsWith(" ") && (r[e + 1] = {
+					kind: "text",
+					text: s.text.slice(1)
+				}), r.splice(e, 1), q(r, i);
+				return;
+			}
+		}, be = (e) => {
+			let t = S.value, n = window.getSelection();
+			if (!t || !n) return null;
+			if (n.rangeCount > 0) {
+				let e = n.getRangeAt(0);
+				if (t.contains(e.startContainer) || e.startContainer === t) return e;
+			}
+			if (!e) return null;
+			if (t.focus(), U(C.value), n.rangeCount > 0) return n.getRangeAt(0);
+			let r = H(t, C.value);
+			return n.removeAllRanges(), n.addRange(r), r;
+		}, Q = (e, t = {}) => {
+			if (!e || D.value || O.value) return;
+			let n = be(t.allowSyntheticSelection === !0);
+			if (!n) throw Error("SInlineTokenEditor: active selection отсутствует в editing surface. / SInlineTokenEditor: no active selection exists inside the editing surface.");
+			let r = ve(n);
+			if (!r) throw Error("SInlineTokenEditor: selection offsets недоступны до readiness. / SInlineTokenEditor: selection offsets are unavailable before readiness.");
+			let i = _e(r.start, r.end, [{
+				kind: "text",
+				text: e
+			}]);
+			q(i, r.start + e.length);
+		}, $ = () => {
+			D.value || O.value || Q("\n", { allowSyntheticSelection: !0 });
+		};
+		_({
+			focus: () => {
+				let e = S.value;
+				if (!e) throw Error("SInlineTokenEditor: editing surface не готова. / SInlineTokenEditor: editing surface is not ready.");
+				e.focus();
+			},
+			insertSoftLineBreak: $,
+			getSelectionOffset: V,
+			queueSelectionOffset: (e) => {
+				w.value = r("SInlineTokenEditor", "queued selection offset", e, {
+					minimum: 0,
+					maximum: 2 ** 53 - 1
+				});
+			},
+			setSelectionOffset: (e) => {
+				let t = d(E.value, e, "imperative selection offset"), n = S.value;
+				if (!n) throw Error("SInlineTokenEditor: editing surface не готова. / SInlineTokenEditor: editing surface is not ready.");
+				if (!window.getSelection()) throw Error("SInlineTokenEditor: Selection API недоступен. / SInlineTokenEditor: Selection API is unavailable.");
+				n.focus(), U(t), w.value = t, y("state-change", {
+					text: M(E.value),
+					cursor: t
+				});
+			},
+			replaceRange: (e) => {
+				if (D.value || O.value) throw Error("SInlineTokenEditor: replaceRange недоступен для disabled или readonly editor. / SInlineTokenEditor: replaceRange is unavailable for a disabled or readonly editor.");
+				let t = S.value;
+				if (!t) throw Error("SInlineTokenEditor: editing surface не готова. / SInlineTokenEditor: editing surface is not ready.");
+				let n = _e(e.start, e.end, e.segments);
+				t.focus(), q(n, e.cursor);
+			}
+		});
+		function xe() {
+			D.value || O.value || K();
+		}
+		function Se(e) {
+			if (!(D.value || O.value || e.defaultPrevented) && !e.isComposing) {
+				if (e.inputType === "deleteContentBackward") {
+					let t = be(!0);
+					if (t && Y(t)) {
+						if (A.value === "newline") {
+							e.preventDefault(), ge();
+							return;
+						}
+						if (A.value === "token") {
+							e.preventDefault(), ye(V());
+							return;
+						}
+						return;
+					}
+					if (t?.collapsed) {
+						e.preventDefault(), ye(V());
+						return;
+					}
+				}
+				if (e.inputType === "insertText" && typeof e.data == "string" && e.data.length > 0) {
+					e.preventDefault(), Q(e.data, { allowSyntheticSelection: !0 });
+					return;
+				}
+				(e.inputType === "insertLineBreak" || e.inputType === "insertParagraph") && (e.preventDefault(), $());
+			}
+		}
+		function Ce(e) {
+			if (D.value || O.value) return;
+			if (e.preventDefault(), !e.clipboardData) throw TypeError("SInlineTokenEditor: paste event не содержит clipboardData. / SInlineTokenEditor: paste event has no clipboardData.");
+			let t = e.clipboardData.getData("text/plain");
+			Q(t);
+		}
+		function we(e) {
+			if (y("keydown", e), D.value || O.value || e.defaultPrevented) return;
+			if (e.key === "Enter" && e.shiftKey) {
+				e.preventDefault(), $();
+				return;
+			}
+			let t = e.key === "Space" || e.key === "Spacebar" || e.code === "Space" ? " " : e.key;
+			!e.isComposing && !e.ctrlKey && !e.metaKey && !e.altKey && t.length === 1 && (e.preventDefault(), Q(t, { allowSyntheticSelection: !0 }));
+		}
+		function Te(e) {
+			y("keyup", e), W();
+		}
+		function Ee(e) {
+			y("click", e), W();
+		}
+		function De(e) {
+			let t = o("SInlineTokenEditor", "token action occurrenceId", e.occurrenceId), n = o("SInlineTokenEditor", "token action id", e.id), r = {
+				occurrenceId: t,
+				id: n
+			};
+			if (e.action === "open") {
+				D.value || y("open-token", r);
+				return;
+			}
+			if (D.value || O.value) return;
+			let i = E.value, a = 0, s = [], c = !1, l = !1;
+			for (let e = 0; e < i.length; e += 1) {
+				let r = i[e], o = l && r.kind === "text" && r.text.startsWith(" ") ? {
+					kind: "text",
+					text: r.text.slice(1)
+				} : r;
+				if (l = !1, o.kind === "token" && o.occurrenceId === t) {
+					if (o.id !== n) throw TypeError(`SInlineTokenEditor: token action id ${JSON.stringify(n)} does not match occurrence ${JSON.stringify(t)}`);
+					c = !0;
+					let r = s[s.length - 1], a = i[e + 1];
+					r?.kind === "text" && a?.kind === "text" && r.text.endsWith(" ") && a.text.startsWith(" ") && (l = !0);
+					continue;
+				}
+				c || (a += X(o)), s.push(o);
+			}
+			if (!c) throw RangeError(`SInlineTokenEditor: token action occurrence ${JSON.stringify(t)} does not exist`);
+			y("remove-token", r), q(s, a);
+		}
+		return g(me, () => {
+			let e = S.value;
+			if (!e) return;
+			let t = w.value;
+			(t !== null || document.activeElement === e || e.contains(document.activeElement)) && (T.value = d(E.value, t ?? V(), "retained selection offset"));
+		}, { flush: "pre" }), g(me, () => {
+			let e = T.value;
+			e !== null && (U(d(E.value, e, "restored selection offset")), T.value = null, w.value = null);
+		}, { flush: "post" }), (t, n) => (ie(), ne(s, {
+			"control-id": x.value,
+			label: p.label,
+			required: ue.value,
+			"help-text": p.helpText,
+			"error-message": p.errorMessage,
+			invalid: de.value,
+			disabled: D.value,
+			readonly: O.value,
+			fill: k.value === "ghost" ? "container" : "content"
+		}, {
+			default: oe((t) => [re(te, {
+				id: x.value,
+				"element-ref": le,
+				"owned-attributes": h(b).bindings(),
+				"field-bindings": he(t),
+				segments: E.value,
+				"trailing-caret-helper": j.value,
+				"open-disabled": D.value,
+				"remove-disabled": D.value || O.value,
+				appearance: k.value,
+				invalid: t.invalid,
+				disabled: t.disabled,
+				readonly: t.readonly,
+				required: t.required,
+				rows: p.rows,
+				"max-rows": p.maxRows,
+				placeholder: p.placeholder,
+				"placeholder-visible": pe.value,
+				"labelled-by": h(e)(h(b).string("aria-labelledby"), t.labelledBy),
+				"described-by": h(e)(h(b).string("aria-describedby"), t.describedBy),
+				onBeforeinput: Se,
+				onInput: xe,
+				onKeydown: we,
+				onKeyup: Te,
+				onClick: Ee,
+				onPaste: Ce,
+				onTokenAction: De
+			}, null, 8, [
+				"id",
+				"owned-attributes",
+				"field-bindings",
+				"segments",
+				"trailing-caret-helper",
+				"open-disabled",
+				"remove-disabled",
+				"appearance",
+				"invalid",
+				"disabled",
+				"readonly",
+				"required",
+				"rows",
+				"max-rows",
+				"placeholder",
+				"placeholder-visible",
+				"labelled-by",
+				"described-by"
+			])]),
+			_: 1
+		}, 8, [
+			"control-id",
+			"label",
+			"required",
+			"help-text",
+			"error-message",
+			"invalid",
+			"disabled",
+			"readonly",
+			"fill"
+		]));
+	}
+});
+//#endregion
+export { _ as default };

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

@@ -0,0 +1,115 @@
+import { Component } from 'vue';
+import { InteractiveElementApi } from '../../../internal/interactiveElement';
+import { SButtonSeverity } from './SButton.vue';
+/** Текстовые native input types с text-editing semantics. / Textual native input types with text-editing semantics. */
+export type SInputTextTextualType = 'text' | 'search' | 'password' | 'email' | 'tel' | 'url';
+/** Числовой native input type; model events остаются строками. / Numeric native input type; model events remain strings. */
+export type SInputTextNumericType = 'number';
+/** Временные native types со строковым browser value. / Temporal native types with a browser-formatted string value. */
+export type SInputTextTemporalType = 'date' | 'datetime-local' | 'month' | 'time' | 'week';
+/** Конечная native type surface владельца SInputText. / Finite native type surface owned by SInputText. */
+export type SInputTextType = SInputTextTextualType | SInputTextNumericType | SInputTextTemporalType;
+export type SInputTextDensity = 'default' | 'compact';
+/**
+ * Дискриминированный native input contract без file/range/choice/button semantics.
+ * Discriminated native input contract without file/range/choice/button semantics.
+ */
+export type SInputTextTypeContract = {
+    family: 'textual';
+    type: SInputTextTextualType;
+} | {
+    family: 'numeric';
+    type: SInputTextNumericType;
+} | {
+    family: 'temporal';
+    type: SInputTextTemporalType;
+};
+export interface Props {
+    modelValue: string | null;
+    /** Стандартные Vue v-model modifiers для строкового input contract. / Standard Vue v-model modifiers for the string input contract. */
+    modelModifiers?: SInputTextModelModifiers;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    monospace?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    density?: SInputTextDensity;
+    appearance?: 'field' | 'grid-cell' | 'workbench-title';
+    invalid?: boolean;
+    errorMessage?: string;
+    helpText?: string;
+    id?: string;
+    name?: string;
+    type?: SInputTextType;
+    trailingIcon?: Component;
+    trailingText?: string;
+    trailingAction?: SInputTextTrailingAction;
+    autocomplete?: string;
+    autocapitalize?: 'none' | 'off' | 'sentences' | 'words' | 'characters';
+    autocorrect?: 'on' | 'off';
+    spellcheck?: boolean;
+}
+export interface SInputTextModelModifiers {
+    trim?: boolean;
+    lazy?: boolean;
+    number?: boolean;
+}
+/**
+ * Типизированное действие в trailing-region поля; geometry принадлежит SInputText/SButton.
+ * Typed trailing action whose geometry is owned by SInputText/SButton.
+ */
+export interface SInputTextTrailingAction {
+    label: string;
+    icon: Component;
+    title?: string;
+    severity?: SButtonSeverity;
+    disabled?: boolean;
+    loading?: boolean;
+}
+/** Native input owner API for focus-managed compound controls. */
+export type SInputTextApi = InteractiveElementApi<HTMLInputElement>;
+declare const __VLS_export: import('vue').DefineComponent<Props, {
+    focus: () => void | undefined;
+    getElement: () => HTMLInputElement;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    focus: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    "update:modelValue": (value: string) => any;
+    "trailing-action": (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onTrailing-action"?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    required: boolean;
+    label: string;
+    id: string;
+    invalid: boolean;
+    size: "sm" | "md" | "lg";
+    type: SInputTextType;
+    name: string;
+    autocomplete: string;
+    placeholder: string;
+    spellcheck: boolean;
+    autocapitalize: "none" | "off" | "sentences" | "words" | "characters";
+    autocorrect: "on" | "off";
+    disabled: boolean;
+    readonly: boolean;
+    helpText: string;
+    errorMessage: string;
+    modelValue: string | null;
+    trailingIcon: Component;
+    density: SInputTextDensity;
+    appearance: "field" | "grid-cell" | "workbench-title";
+    monospace: boolean;
+    modelModifiers: SInputTextModelModifiers;
+    trailingText: string;
+    trailingAction: SInputTextTrailingAction;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

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