@pgcorp/ui-kit 0.10.0 → 0.10.2

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

@@ -0,0 +1,414 @@
+import { mergeIdReferences as e, useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { resolveOptionalDomId as n, validateBoolean as r, validateBoundedInteger as i, validateBoundedNumber as a, validateDomId as o, validateExactString as s } from "../../../internal/runtimeContract.js";
+import { useInteractiveLeafRegistration as c } from "../../../internal/passiveContentContract.js";
+import l from "./SField.vue.js";
+import { resolveFieldSurfaceBindings as ee } from "../../../internal/fieldSurface.js";
+import { computed as u, createBlock as d, createElementVNode as te, defineComponent as f, mergeProps as ne, nextTick as p, onBeforeUnmount as re, onMounted as ie, openBlock as ae, ref as m, unref as h, useId as oe, watch as g, withCtx as _ } from "vue";
+//#region src/components/shared/controls/STextarea.vue?vue&type=script&setup=true&lang.ts
+var se = [
+	"id",
+	"data-appearance",
+	"data-size",
+	"data-monospace",
+	"data-auto-resize",
+	"data-max-rows",
+	"data-min-height",
+	"data-max-height",
+	"data-invalid",
+	"value",
+	"placeholder",
+	"disabled",
+	"readonly",
+	"required",
+	"aria-invalid",
+	"aria-required",
+	"aria-readonly",
+	"aria-describedby",
+	"aria-controls",
+	"aria-activedescendant",
+	"aria-autocomplete",
+	"aria-haspopup",
+	"rows"
+], v = 100, y = /*@__PURE__*/ f({
+	inheritAttrs: !1,
+	__name: "STextarea",
+	props: {
+		modelValue: { default: "" },
+		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 },
+		size: { default: "md" },
+		autoResize: {
+			type: Boolean,
+			default: !1
+		},
+		maxRows: { default: void 0 },
+		minHeight: { default: void 0 },
+		maxHeight: { default: void 0 },
+		suggestions: { default: void 0 },
+		appearance: { default: "default" },
+		monospace: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"keydown",
+		"keyup",
+		"click",
+		"paste",
+		"compositionstart",
+		"compositionupdate",
+		"compositionend",
+		"selection-change",
+		"state-change"
+	],
+	setup(f, { expose: y, emit: ce }) {
+		let le = ["default", "ghost"], ue = [
+			"sm",
+			"md",
+			"lg"
+		], b = {
+			minimum: 1,
+			maximum: 100
+		}, x = {
+			minimum: 1,
+			maximum: 4096
+		}, de = [
+			"list",
+			"both",
+			"inline",
+			"none"
+		], fe = [
+			"listbox",
+			"grid",
+			"tree",
+			"dialog"
+		], S = [
+			"forward",
+			"backward",
+			"none"
+		], pe = [
+			"select",
+			"start",
+			"end",
+			"preserve"
+		], C = f, w = ce, T = t({
+			component: "STextarea",
+			owner: "native textarea"
+		});
+		c({ owner: "STextarea" });
+		let me = oe(), E = u(() => n("STextarea", "id", C.id, `s-textarea-${me}`)), D = m(null), O = m(!1), k = null, A = null, j = null, M = null, N = !1, P = [], F = [], I = u(() => s("STextarea", "appearance", C.appearance, le)), L = u(() => s("STextarea", "size", C.size, ue)), R = u(() => i("STextarea", "rows", C.rows, b)), z = u(() => C.maxRows === void 0 ? void 0 : i("STextarea", "maxRows", C.maxRows, b)), B = u(() => C.minHeight === void 0 ? void 0 : a("STextarea", "minHeight", C.minHeight, x)), V = u(() => C.maxHeight === void 0 ? void 0 : a("STextarea", "maxHeight", C.maxHeight, x)), H = u(() => {
+			if (C.suggestions === void 0) return;
+			if (C.suggestions === null || typeof C.suggestions != "object" || Array.isArray(C.suggestions)) throw TypeError("STextarea: suggestions должен быть объектом. / STextarea: suggestions must be an object.");
+			let e = C.suggestions.activeDescendant === void 0 ? void 0 : o("STextarea", "suggestions.activeDescendant", C.suggestions.activeDescendant);
+			return {
+				controls: o("STextarea", "suggestions.controls", C.suggestions.controls),
+				activeDescendant: e,
+				autocomplete: s("STextarea", "suggestions.autocomplete", C.suggestions.autocomplete ?? "list", de),
+				popupRole: s("STextarea", "suggestions.popupRole", C.suggestions.popupRole ?? "listbox", fe)
+			};
+		}), U = u(() => {
+			let e = r("STextarea", "autoResize", C.autoResize), t = z.value, n = B.value, i = V.value;
+			if (!e && t !== void 0 && n === void 0 && i === void 0) throw TypeError(`STextarea: maxRows применяется только при autoResize=true; получено autoResize=false, maxRows=${t}. / STextarea: maxRows applies only when autoResize=true; received autoResize=false, maxRows=${t}.`);
+			if (!e && (n !== void 0 || i !== void 0)) throw TypeError("STextarea: maxRows/minHeight/maxHeight применяются только при autoResize=true. / STextarea: maxRows/minHeight/maxHeight apply only when autoResize=true.");
+			if (t !== void 0 && i !== void 0) throw TypeError("STextarea: maxRows и maxHeight являются альтернативными ограничителями; укажите один. / STextarea: maxRows and maxHeight are alternative bounds; provide one.");
+			if (n !== void 0 && i !== void 0 && i < n) throw TypeError(`STextarea: maxHeight не может быть меньше minHeight; получено minHeight=${n}, maxHeight=${i}. / STextarea: maxHeight cannot be below minHeight; received minHeight=${n}, maxHeight=${i}.`);
+			if (t !== void 0 && t < R.value) throw TypeError(`STextarea: maxRows не может быть меньше rows; получено rows=${R.value}, maxRows=${t}. / STextarea: maxRows cannot be less than rows; received rows=${R.value}, maxRows=${t}.`);
+			return e ? {
+				mode: "content",
+				autoResize: !0,
+				...t === void 0 ? {} : { maxRows: t },
+				...n === void 0 ? {} : { minHeight: n },
+				...i === void 0 ? {} : { maxHeight: i }
+			} : {
+				mode: "fixed",
+				autoResize: !1
+			};
+		});
+		function he(e) {
+			return ee("STextarea", {
+				kind: "textarea",
+				appearance: I.value === "default" ? "field" : "ghost",
+				invalid: e.invalid,
+				disabled: e.disabled,
+				readonly: e.readonly
+			});
+		}
+		function W(e, t) {
+			let n = Z(e.selectionStart, e.value.length, `${t} selectionStart`), r = Z(e.selectionEnd, e.value.length, `${t} selectionEnd`);
+			if (r < n) throw RangeError(`STextarea: ${t} selectionEnd=${r} is below selectionStart=${n}.`);
+			return {
+				start: n,
+				end: r,
+				direction: s("STextarea", `${t} selectionDirection`, e.selectionDirection ?? "none", S)
+			};
+		}
+		function G(e) {
+			let t = W(e, "state-change");
+			w("state-change", {
+				text: e.value,
+				cursor: t.start,
+				selection: t,
+				composing: O.value
+			});
+		}
+		function ge(e) {
+			let t = e.target, n = e instanceof InputEvent ? e.inputType : "";
+			!N && n !== "historyUndo" && n !== "historyRedo" && F.splice(0), w("update:modelValue", t.value), G(t), p(Y);
+		}
+		function K(e, t) {
+			return {
+				text: e.value,
+				selection: W(e, t)
+			};
+		}
+		function q(e, t) {
+			e.value = t.text, e.focus(), e.setSelectionRange(t.selection.start, t.selection.end, t.selection.direction), w("update:modelValue", t.text), w("selection-change", t.selection), G(e), p(Y);
+		}
+		function _e(e, t) {
+			return e.value === t.text;
+		}
+		function ve(e, t) {
+			if (e.altKey || !(e.metaKey || e.ctrlKey)) return !1;
+			let n = e.key.toLowerCase(), r = n === "z" && !e.shiftKey, i = n === "z" && e.shiftKey || n === "y" && !e.shiftKey;
+			if (!r && !i) return !1;
+			let a = r ? P : F, o = a[a.length - 1], s = r ? o?.after : o?.before;
+			return !o || !s || !_e(t, s) ? !1 : (e.preventDefault(), a.pop(), r ? (F.push(o), q(t, o.before)) : (P.push(o), q(t, o.after)), !0);
+		}
+		function ye(e) {
+			w("keydown", e), !(e.defaultPrevented || O.value || C.disabled || C.readonly) && ve(e, e.currentTarget);
+		}
+		function be(e) {
+			w("keyup", e), G(e.currentTarget);
+		}
+		function xe(e) {
+			w("click", e), G(e.currentTarget);
+		}
+		function Se(e) {
+			let t = e.currentTarget, n = W(t, "selection-change");
+			w("selection-change", n), G(t);
+		}
+		function Ce(e) {
+			O.value = !0, w("compositionstart", e), G(e.currentTarget);
+		}
+		function we(e) {
+			w("compositionupdate", e), G(e.currentTarget);
+		}
+		function Te(e) {
+			O.value = !1, w("compositionend", e), G(e.currentTarget), Y();
+		}
+		function J() {
+			let e = D.value, t = U.value;
+			if (t.mode === "fixed" || !e || e.scrollHeight === 0) return;
+			let n = window.getComputedStyle(e), r = Number.parseFloat(n.lineHeight) || Number.parseFloat(n.fontSize) * 1.5, i = Number.parseFloat(n.paddingTop) || 0, a = Number.parseFloat(n.paddingBottom) || 0, o = R.value * r + i + a, s = t.minHeight ?? o, c = t.maxHeight ?? (t.maxRows === void 0 ? 0 : t.maxRows * r + i + a);
+			if (c > 0 && c < s) throw RangeError(`STextarea: вычисленный maxHeight=${c} меньше minimumHeight=${s}. / STextarea: resolved maxHeight=${c} is below minimumHeight=${s}.`);
+			if (C.disabled || C.modelValue === null || C.modelValue.length === 0) {
+				e.style.height = `${s}px`, e.style.overflowY = "hidden";
+				return;
+			}
+			e.style.height = "auto";
+			let l = e.scrollHeight;
+			if (c > 0 && l > c) {
+				e.style.height = `${c}px`, e.style.overflowY = "auto";
+				return;
+			}
+			e.style.height = `${Math.max(s, l)}px`, e.style.overflowY = "hidden";
+		}
+		function Y() {
+			M === null && U.value.mode !== "fixed" && (M = window.requestAnimationFrame(() => {
+				M = null, J();
+			}));
+		}
+		function Ee() {
+			D.value?.focus();
+		}
+		function X(e) {
+			let t = D.value;
+			if (!t) throw Error(`STextarea: textarea не готова для ${e}; дождитесь mount. / STextarea: textarea is not ready for ${e}; wait for mount.`);
+			return t;
+		}
+		function Z(e, t, n) {
+			return i("STextarea", n, e, {
+				minimum: 0,
+				maximum: t
+			});
+		}
+		function De() {
+			let e = X("getSelectionOffset");
+			return Z(e.selectionStart, e.value.length, "getSelectionOffset");
+		}
+		function Oe() {
+			return W(X("getSelection"), "getSelection");
+		}
+		function Q(e, t, n) {
+			if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError(`STextarea: ${n} должен быть selection object. / STextarea: ${n} must be a selection object.`);
+			let r = Z(e.start, t, `${n}.start`), i = Z(e.end, t, `${n}.end`);
+			if (i < r) throw RangeError(`STextarea: ${n}.end=${i} меньше ${n}.start=${r}.`);
+			return {
+				start: r,
+				end: i,
+				direction: s("STextarea", `${n}.direction`, e.direction, S)
+			};
+		}
+		function ke(e, t = !0) {
+			let n = X("setSelection"), r = Q(e, n.value.length, "setSelection");
+			t && n.focus(), n.setSelectionRange(r.start, r.end, r.direction), w("selection-change", r), G(n);
+		}
+		function Ae(e) {
+			let t = X("setSelectionOffset"), n = Z(e, t.value.length, "setSelectionOffset");
+			t.focus(), t.setSelectionRange(n, n);
+		}
+		function $(e, t = {}) {
+			let n = X("replaceSelection");
+			if (C.disabled || C.readonly) throw Error("STextarea: replaceSelection недоступен для disabled/readonly поля. / STextarea: replaceSelection is unavailable for a disabled/readonly field.");
+			if (O.value) throw Error("STextarea: replaceSelection недоступен во время IME composition. / STextarea: replaceSelection is unavailable during IME composition.");
+			if (typeof e != "string") throw TypeError("STextarea: replaceSelection text должен быть строкой. / STextarea: replaceSelection text must be a string.");
+			let r = t.selection === void 0 ? W(n, "replaceSelection") : Q(t.selection, n.value.length, "replaceSelection.selection"), i = s("STextarea", "replaceSelection.selectionMode", t.selectionMode ?? "end", pe);
+			(t.focus ?? !0) && n.focus();
+			let a = K(n, "replaceSelection before");
+			n.setRangeText(e, r.start, r.end, i);
+			let o = K(n, "replaceSelection after");
+			P.push({
+				before: a,
+				after: o
+			}), P.length > v && P.shift(), F.splice(0), N = !0;
+			try {
+				n.dispatchEvent(new InputEvent("input", {
+					bubbles: !0,
+					composed: !0,
+					data: e,
+					inputType: "insertReplacementText"
+				}));
+			} finally {
+				N = !1;
+			}
+			w("selection-change", o.selection);
+			let c = o.selection;
+			return {
+				text: n.value,
+				cursor: c.start,
+				selection: c,
+				composing: O.value
+			};
+		}
+		function je() {
+			C.disabled || C.readonly || $("\n");
+		}
+		return y({
+			focus: Ee,
+			getSelection: Oe,
+			getSelectionOffset: De,
+			insertSoftLineBreak: je,
+			replaceSelection: $,
+			resize: J,
+			setSelection: ke,
+			setSelectionOffset: Ae
+		}), ie(() => {
+			J(), A = D.value?.parentElement ?? null, typeof ResizeObserver < "u" && A && (k = new ResizeObserver((e) => {
+				let t = e.find((e) => e.target === A);
+				if (!t) return;
+				let n = t.contentRect.width;
+				n !== j && (j = n, Y());
+			}), k.observe(A));
+		}), g(() => [
+			C.modelValue,
+			C.disabled,
+			C.rows,
+			C.maxRows,
+			C.minHeight,
+			C.maxHeight
+		], () => {
+			p(Y);
+		}), g(() => C.modelValue, (e) => {
+			let t = D.value;
+			t && t.value !== (e ?? "") && (P.splice(0), F.splice(0));
+		}), re(() => {
+			M !== null && window.cancelAnimationFrame(M), k?.disconnect(), k = null, A = null, P.splice(0), F.splice(0);
+		}), (t, n) => (ae(), d(l, {
+			"control-id": E.value,
+			label: f.label,
+			required: f.required,
+			"help-text": f.helpText,
+			"error-message": f.errorMessage,
+			invalid: f.invalid,
+			disabled: f.disabled,
+			readonly: f.readonly,
+			fill: I.value === "ghost" ? "container" : "content"
+		}, {
+			default: _((t) => [te("textarea", ne({
+				...h(T).bindings(),
+				...he(t)
+			}, {
+				id: E.value,
+				ref_key: "textareaRef",
+				ref: D,
+				class: "s-textarea",
+				"data-appearance": I.value,
+				"data-size": L.value,
+				"data-monospace": f.monospace || void 0,
+				"data-auto-resize": U.value.mode === "content" || void 0,
+				"data-max-rows": z.value,
+				"data-min-height": B.value,
+				"data-max-height": V.value,
+				"data-invalid": t.invalid || void 0,
+				value: f.modelValue,
+				placeholder: f.placeholder,
+				disabled: t.disabled,
+				readonly: t.readonly,
+				required: t.required,
+				"aria-invalid": t.invalid || void 0,
+				"aria-required": t.required || void 0,
+				"aria-readonly": t.readonly || void 0,
+				"aria-describedby": h(e)(h(T).string("aria-describedby"), t.describedBy),
+				"aria-controls": H.value?.controls,
+				"aria-activedescendant": H.value?.activeDescendant,
+				"aria-autocomplete": H.value?.autocomplete,
+				"aria-haspopup": H.value?.popupRole,
+				rows: R.value,
+				onInput: ge,
+				onKeydown: ye,
+				onKeyup: be,
+				onClick: xe,
+				onSelect: Se,
+				onPaste: n[0] ||= (e) => w("paste", e),
+				onCompositionstart: Ce,
+				onCompositionupdate: we,
+				onCompositionend: Te
+			}), null, 16, se)]),
+			_: 1
+		}, 8, [
+			"control-id",
+			"label",
+			"required",
+			"help-text",
+			"error-message",
+			"invalid",
+			"disabled",
+			"readonly",
+			"fill"
+		]));
+	}
+});
+//#endregion
+export { y as default };

package/dist/src/components/shared/controls/_internal/SInlineTokenSurface.vue.d.ts

@@ -0,0 +1,199 @@
+import { ComponentPublicInstance, PropType } from 'vue';
+import { FieldSurfaceBindings } from '../../../../internal/fieldSurface';
+import { InlineTokenEditorSegmentContract } from '../../../../internal/inlineTokenEditorContract';
+import { OwnedAttributeBindings } from '../../../../internal/ownedAttrs';
+/** Текст визуального caret helper. / Visual caret-helper text. */
+export declare const INLINE_TOKEN_EDITOR_VISUAL_CARET_TEXT = "\u200B";
+/** Действие над одним token occurrence. / Action for one token occurrence. */
+export type InlineTokenAction = 'open' | 'remove';
+/** Точное событие token action. / Exact token-action event. */
+export interface InlineTokenActionEvent {
+    readonly action: InlineTokenAction;
+    readonly occurrenceId: string;
+    readonly id: string;
+}
+/** Ref-контракт native editing surface. / Native editing-surface ref contract. */
+export type InlineTokenElementRef = (target: Element | ComponentPublicInstance | null, refs: Record<string, unknown>) => void;
+/**
+ * Private leaf-владелец exact contenteditable DOM, ARIA, field surface и token actions.
+ * Private leaf owner of the exact contenteditable DOM, ARIA, field surface, and token actions.
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+    elementRef: {
+        type: PropType<InlineTokenElementRef>;
+        required: true;
+    };
+    ownedAttributes: {
+        type: PropType<OwnedAttributeBindings<"SInlineTokenEditor">>;
+        required: true;
+    };
+    fieldBindings: {
+        type: PropType<FieldSurfaceBindings>;
+        required: true;
+    };
+    segments: {
+        type: PropType<readonly InlineTokenEditorSegmentContract[]>;
+        required: true;
+    };
+    trailingCaretHelper: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    openDisabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    removeDisabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    appearance: {
+        type: PropType<"default" | "ghost">;
+        required: true;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    required: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    rows: {
+        type: NumberConstructor;
+        required: true;
+    };
+    maxRows: {
+        type: NumberConstructor;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    placeholderVisible: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    labelledBy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    describedBy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    beforeinput: (_event: InputEvent) => true;
+    input: (_event: Event) => true;
+    keydown: (_event: KeyboardEvent) => true;
+    keyup: (_event: KeyboardEvent) => true;
+    click: (_event: MouseEvent) => true;
+    paste: (_event: ClipboardEvent) => true;
+    tokenAction: (event: InlineTokenActionEvent) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+    elementRef: {
+        type: PropType<InlineTokenElementRef>;
+        required: true;
+    };
+    ownedAttributes: {
+        type: PropType<OwnedAttributeBindings<"SInlineTokenEditor">>;
+        required: true;
+    };
+    fieldBindings: {
+        type: PropType<FieldSurfaceBindings>;
+        required: true;
+    };
+    segments: {
+        type: PropType<readonly InlineTokenEditorSegmentContract[]>;
+        required: true;
+    };
+    trailingCaretHelper: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    openDisabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    removeDisabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    appearance: {
+        type: PropType<"default" | "ghost">;
+        required: true;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    required: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    rows: {
+        type: NumberConstructor;
+        required: true;
+    };
+    maxRows: {
+        type: NumberConstructor;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    placeholderVisible: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    labelledBy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    describedBy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onInput?: ((_event: Event) => any) | undefined;
+    onBeforeinput?: ((_event: InputEvent) => any) | undefined;
+    onClick?: ((_event: MouseEvent) => any) | undefined;
+    onKeydown?: ((_event: KeyboardEvent) => any) | undefined;
+    onKeyup?: ((_event: KeyboardEvent) => any) | undefined;
+    onPaste?: ((_event: ClipboardEvent) => any) | undefined;
+    onTokenAction?: ((event: InlineTokenActionEvent) => any) | undefined;
+}>, {
+    placeholder: string;
+    describedBy: string;
+    labelledBy: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/src/components/shared/controls/_internal/SInlineTokenSurface.vue.js

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