@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/data-display/STooltip.vue.d.ts

@@ -0,0 +1,92 @@
+import { VNodeChild, VNodeRef } from 'vue';
+export type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+export type TooltipDetailPresentation = 'text' | 'badge' | 'code';
+export type TooltipDetailTone = 'neutral' | 'info' | 'success' | 'warn' | 'danger';
+export interface TooltipDetail {
+    id: string;
+    label: string;
+    value: string | number;
+    presentation?: TooltipDetailPresentation;
+    tone?: TooltipDetailTone;
+}
+export interface TooltipSectionItem {
+    id: string;
+    label: string;
+}
+export interface TooltipSection {
+    id: string;
+    title: string;
+    description?: string;
+    items?: readonly TooltipSectionItem[];
+}
+/**
+ * Декларативные ARIA/ref/event bindings, которые применяет сам trigger leaf.
+ * Declarative ARIA/ref/event bindings applied by the trigger leaf itself.
+ */
+export interface STooltipTriggerBinding {
+    readonly ref: VNodeRef;
+    readonly 'aria-describedby': string | undefined;
+    readonly onPointerenter: (event: PointerEvent) => void;
+    readonly onPointerleave: (event: PointerEvent) => void;
+    readonly onPointerdown: (event: PointerEvent) => void;
+    readonly onPointerup: (event: PointerEvent) => void;
+    readonly onPointercancel: (event: PointerEvent) => void;
+    readonly onFocusin: () => void;
+    readonly onFocusout: (event: FocusEvent) => void;
+}
+/** Focus/ARIA owner для split trigger без pointer geometry. / Focus and ARIA owner for a split trigger without pointer geometry. */
+export interface STooltipFocusOwnerBinding {
+    readonly ref: VNodeRef;
+    readonly 'aria-describedby': string | undefined;
+    readonly onFocusin: () => void;
+    readonly onFocusout: (event: FocusEvent) => void;
+}
+/** Пассивная pointer/geometry target той же интерактивной композиции. / Passive pointer and geometry target in the same interactive composition. */
+export interface STooltipPointerTargetBinding {
+    readonly ref: VNodeRef;
+    readonly onPointerenter: (event: PointerEvent) => void;
+    readonly onPointerleave: (event: PointerEvent) => void;
+}
+/** Scoped-slot API явного trigger owner. / Scoped-slot API for the explicit trigger owner. */
+export interface STooltipTriggerSlotProps {
+    readonly trigger: STooltipTriggerBinding;
+    readonly focusOwner: STooltipFocusOwnerBinding;
+    readonly pointerTarget: STooltipPointerTargetBinding;
+    readonly isOpen: boolean;
+}
+export interface Props {
+    text?: string;
+    title?: string;
+    description?: string;
+    details?: readonly TooltipDetail[];
+    sections?: readonly TooltipSection[];
+    position?: TooltipPosition;
+    disabled?: boolean;
+    showDelay?: number;
+    hideDelay?: number;
+    triggerDescribedBy?: string;
+}
+type __VLS_Slots = {
+    /** Ровно один leaf обязан применить trigger binding. / Exactly one leaf must apply the trigger binding. */
+    default: (scope: STooltipTriggerSlotProps) => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    details: readonly TooltipDetail[];
+    title: string;
+    text: string;
+    position: TooltipPosition;
+    sections: readonly TooltipSection[];
+    disabled: boolean;
+    description: string;
+    showDelay: number;
+    hideDelay: number;
+    triggerDescribedBy: 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/data-display/STooltip.vue.js

@@ -0,0 +1,7 @@
+import "../../../../assets/src/components/shared/data-display/STooltip.css_vue_type_style_index_0_src_true_lang.css";
+import e from "./STooltip.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                  */
+//#region src/components/shared/data-display/STooltip.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/src/components/shared/data-display/STooltip.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,352 @@
+import { hasOwn as e } from "../../../internal/es2020.js";
+import { isFocusableElement as t } from "../../../internal/focusNavigation.js";
+import { registerLayer as n } from "../../../internal/layerStack.js";
+import { useFloatingPosition as r } from "../../../composables/useFloatingPosition.js";
+import { mergeIdReferences as i, useOwnedAttrs as a } from "../../../internal/ownedAttrs.js";
+import { validateBoolean as o, validateDomId as ee, validateExactString as s, validateNonEmptyString as c } from "../../../internal/runtimeContract.js";
+import { resolveSemanticToneBinding as te } from "../../../internal/semanticTone.js";
+import ne from "./SBadge.vue.js";
+import { resolveInteractiveElement as l } from "../../../internal/interactiveElement.js";
+import { Fragment as u, Teleport as re, Transition as ie, computed as d, createBlock as ae, createCommentVNode as f, createElementBlock as p, createElementVNode as m, createTextVNode as oe, createVNode as se, defineComponent as ce, normalizeStyle as le, onBeforeUnmount as ue, onMounted as de, openBlock as h, ref as fe, renderList as g, renderSlot as pe, toDisplayString as _, unref as v, useId as me, watch as he, watchEffect as ge, withCtx as _e } from "vue";
+//#region src/components/shared/data-display/STooltip.vue?vue&type=script&setup=true&lang.ts
+var ve = ["data-placement"], ye = { class: "s-tooltip__content" }, be = {
+	key: 0,
+	class: "s-tooltip__title"
+}, xe = {
+	key: 1,
+	class: "s-tooltip__description"
+}, Se = {
+	key: 2,
+	class: "s-tooltip__text"
+}, Ce = {
+	key: 3,
+	class: "s-tooltip__details"
+}, we = { class: "s-tooltip__detail-label" }, Te = ["data-presentation", "data-s-tone"], Ee = {
+	key: 4,
+	class: "s-tooltip__sections"
+}, De = { class: "s-tooltip__section-title" }, Oe = {
+	key: 0,
+	class: "s-tooltip__section-description"
+}, ke = {
+	key: 1,
+	class: "s-tooltip__section-items"
+}, y = /*@__PURE__*/ ce({
+	inheritAttrs: !1,
+	__name: "STooltip",
+	props: {
+		text: { default: "" },
+		title: { default: void 0 },
+		description: { default: void 0 },
+		details: { default: () => [] },
+		sections: { default: () => [] },
+		position: { default: "top" },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		showDelay: { default: 120 },
+		hideDelay: { default: 80 },
+		triggerDescribedBy: { default: void 0 }
+	},
+	setup(ce) {
+		let y = ce, b = (e) => /* @__PURE__ */ Error(`STooltip: ${e}`), x = fe(!1), Ae = a({
+			component: "STooltip",
+			owner: "renderless tooltip contract"
+		}), S = fe("var(--s-layer-root-floating)"), C = null, w = null, T = null, E = null, D = null, O = null, k = null, A = null, j = !1, M = !1, N = !1, P = `s-tooltip-${me()}`;
+		function F(e, t) {
+			return t === void 0 || t === "" ? void 0 : c("STooltip", e, t);
+		}
+		function I(e, t) {
+			if (typeof t != "object" || !t || Array.isArray(t) || Object.getPrototypeOf(t) !== Object.prototype) throw b(`${e} должен быть plain object. ${e} must be a plain object.`);
+			return t;
+		}
+		function L(e, t, n) {
+			let r = Object.keys(t).filter((e) => !n.includes(e));
+			if (r.length > 0) throw b(`${e} содержит неизвестные поля ${r.join(", ")}. ${e} contains unknown fields ${r.join(", ")}.`);
+		}
+		function R(t, n) {
+			if (!Array.isArray(n)) throw b(`${t} должен быть массивом. ${t} must be an array.`);
+			for (let r = 0; r < n.length; r += 1) if (!e(n, r)) throw b(`${t}[${r}] отсутствует в sparse array. ${t}[${r}] is missing from a sparse array.`);
+			return n;
+		}
+		function z(e, t, n, r) {
+			let i = e.get(t);
+			if (i !== void 0) throw b(`${n}[${r}].id дублирует ${JSON.stringify(t)} из ${n}[${i}].id. ${n}[${r}].id duplicates ${JSON.stringify(t)} from ${n}[${i}].id.`);
+			e.set(t, r);
+		}
+		function je(e) {
+			let t = R("details", e), n = /* @__PURE__ */ new Map();
+			return t.map((e, t) => {
+				let r = `details[${t}]`, i = I(r, e);
+				L(r, i, [
+					"id",
+					"label",
+					"value",
+					"presentation",
+					"tone"
+				]);
+				let a = c("STooltip", `${r}.id`, i.id);
+				z(n, a, "details", t);
+				let o = i.value;
+				if (!(typeof o == "string" && o.length > 0) && !(typeof o == "number" && Number.isFinite(o))) throw b(`${r}.value должен быть непустой строкой или конечным числом. ${r}.value must be a non-empty string or finite number.`);
+				return {
+					id: a,
+					label: c("STooltip", `${r}.label`, i.label),
+					value: o,
+					...i.presentation === void 0 ? {} : { presentation: s("STooltip", `${r}.presentation`, i.presentation, [
+						"text",
+						"badge",
+						"code"
+					]) },
+					...i.tone === void 0 ? {} : { tone: s("STooltip", `${r}.tone`, i.tone, [
+						"neutral",
+						"info",
+						"success",
+						"warn",
+						"danger"
+					]) }
+				};
+			});
+		}
+		function Me(e) {
+			let t = R("sections", e), n = /* @__PURE__ */ new Map();
+			return t.map((e, t) => {
+				let r = `sections[${t}]`, i = I(r, e);
+				L(r, i, [
+					"id",
+					"title",
+					"description",
+					"items"
+				]);
+				let a = c("STooltip", `${r}.id`, i.id);
+				z(n, a, "sections", t);
+				let o = i.items === void 0 ? void 0 : (() => {
+					let e = R(`${r}.items`, i.items), t = /* @__PURE__ */ new Map();
+					return e.map((e, n) => {
+						let i = `${r}.items[${n}]`, a = I(i, e);
+						L(i, a, ["id", "label"]);
+						let o = c("STooltip", `${i}.id`, a.id);
+						return z(t, o, `${r}.items`, n), {
+							id: o,
+							label: c("STooltip", `${i}.label`, a.label)
+						};
+					});
+				})();
+				return {
+					id: a,
+					title: c("STooltip", `${r}.title`, i.title),
+					...i.description === void 0 ? {} : { description: c("STooltip", `${r}.description`, i.description) },
+					...o === void 0 ? {} : { items: o }
+				};
+			});
+		}
+		let B = d(() => F("text", y.text)), V = d(() => F("title", y.title)), H = d(() => F("description", y.description)), U = d(() => je(y.details)), W = d(() => Me(y.sections)), Ne = d(() => {
+			let e = B.value, t = V.value, n = H.value, r = U.value, i = W.value;
+			return !!(e || t || n || r.length > 0 || i.length > 0);
+		}), Pe = {
+			neutral: "secondary",
+			info: "info",
+			success: "success",
+			warn: "warn",
+			danger: "danger"
+		}, Fe = (e) => Pe[e ?? "neutral"], Ie = (e) => te("STooltip", "detail.tone", e ?? "neutral", [
+			"neutral",
+			"info",
+			"success",
+			"warn",
+			"danger"
+		]), Le = d(() => `${y.position}-center`), { anchorRef: G, panelRef: Re, floatingStyle: ze, arrowStyle: Be, resolvedPlacement: Ve } = r({
+			active: x,
+			placement: () => Le.value,
+			offset: () => 6,
+			boundaryPadding: () => 6,
+			flip: () => !0,
+			shift: () => !0,
+			widthMatch: () => "none",
+			zIndex: () => S.value,
+			scrollStrategy: "close",
+			requestClose: () => J()
+		}), K = () => {
+			w !== null && (clearTimeout(w), w = null);
+		}, q = () => {
+			T !== null && (window.clearTimeout(T), T = null);
+		}, J = () => {
+			K(), q(), x.value = !1, C?.unregister({ restoreFocus: !1 }), C = null, S.value = "var(--s-layer-root-floating)";
+		}, He = () => {
+			!x.value && k && A && (C = n({
+				kind: "tooltip",
+				root: () => Re.value,
+				anchor: () => G.value,
+				blocksParentFocusTrap: !1,
+				restoreTarget: null,
+				requestDismiss: J
+			}), S.value = C.zIndex, x.value = !0);
+		}, Y = () => {
+			!y.disabled && Ne.value && k && A && (K(), q(), T = window.setTimeout(() => {
+				T = null, He();
+			}, y.showDelay));
+		}, Ue = () => {
+			q(), K(), w = window.setTimeout(() => {
+				w = null, J();
+			}, y.hideDelay);
+		}, X = () => {
+			!j && !M && !N && Ue();
+		}, We = (e) => {
+			e.pointerType !== "touch" && (j = !0, Y());
+		}, Ge = (e) => {
+			e.pointerType !== "touch" && (j = !1, X());
+		}, Ke = (e) => {
+			e.pointerType === "touch" && (N = !0, Y());
+		}, qe = (e) => {
+			e.pointerType === "touch" && (N = !1, X());
+		}, Je = () => {
+			M = !0, Y();
+		}, Ye = (e) => {
+			e.relatedTarget instanceof Node && k?.contains(e.relatedTarget) || (M = !1, X());
+		}, Xe = () => {
+			if (k && A && E === null && k === A) throw b("focusOwner и pointerTarget должны быть разными владельцами одной интерактивной композиции. focusOwner and pointerTarget must be distinct owners in one interactive composition.");
+		}, Z = (e) => {
+			if (e !== null && !t(e)) throw b("trigger/focusOwner должен владеть canonical focus owner; используйте интерактивный UI-kit leaf. trigger/focusOwner must own a canonical focus owner; use an interactive UI-kit leaf.");
+			k = e, j = !1, M = !1, N = !1, e === null && J(), Xe();
+		}, Q = (e) => {
+			if (e !== null && E === null && t(e)) throw b("pointerTarget должен быть пассивным и не может создавать дополнительный tab stop. pointerTarget must be passive and cannot create an additional tab stop.");
+			A = e, G.value = e, j = !1, N = !1, e === null && J(), Xe();
+		}, $ = (e) => {
+			if (e === "combined" && (D !== null || O !== null)) throw b("combined trigger нельзя смешивать со split trigger. combined trigger cannot be mixed with a split trigger.");
+			if (e !== "combined" && E !== null) throw b("split trigger нельзя смешивать с combined trigger. A split trigger cannot be mixed with a combined trigger.");
+		}, Ze = (e) => {
+			if (e !== E) {
+				if (e !== null && ($("combined"), E !== null)) throw b("trigger binding применён более чем к одному leaf. The trigger binding was applied to more than one leaf.");
+				E = e, (e === null || e instanceof HTMLElement) && (Z(e), Q(e));
+			}
+		}, Qe = (e) => {
+			if (e !== D) {
+				if (e !== null && ($("focusOwner"), D !== null)) throw b("focusOwner binding применён более чем к одному leaf. focusOwner binding was applied to more than one leaf.");
+				D = e, (e === null || e instanceof HTMLElement) && Z(e);
+			}
+		}, $e = (e) => {
+			if (e !== O) {
+				if (e !== null && ($("pointerTarget"), O !== null)) throw b("pointerTarget binding применён более чем к одному leaf. pointerTarget binding was applied to more than one leaf.");
+				O = e, (e === null || e instanceof HTMLElement) && Q(e);
+			}
+		}, et = d(() => {
+			if (y.triggerDescribedBy === void 0) return;
+			if (typeof y.triggerDescribedBy != "string") throw b("triggerDescribedBy должен быть строкой DOM id references. triggerDescribedBy must be a string of DOM id references.");
+			let e = y.triggerDescribedBy.trim().split(/\s+/u).filter(Boolean);
+			if (e.length === 0) throw b("triggerDescribedBy должен содержать хотя бы один DOM id. triggerDescribedBy must contain at least one DOM id.");
+			return e.map((e, t) => ee("STooltip", `triggerDescribedBy[${t}]`, e)).join(" ");
+		}), tt = d(() => ({
+			ref: Ze,
+			"aria-describedby": i(et.value, x.value ? P : void 0),
+			onPointerenter: We,
+			onPointerleave: Ge,
+			onPointerdown: Ke,
+			onPointerup: qe,
+			onPointercancel: qe,
+			onFocusin: Je,
+			onFocusout: Ye
+		})), nt = d(() => ({
+			ref: Qe,
+			"aria-describedby": i(et.value, x.value ? P : void 0),
+			onFocusin: Je,
+			onFocusout: Ye
+		})), rt = d(() => ({
+			ref: $e,
+			onPointerenter: We,
+			onPointerleave: Ge
+		})), it = () => {
+			x.value && J();
+		}, at = () => {
+			document.hidden && x.value && J();
+		}, ot = () => {
+			window.addEventListener("blur", it), document.addEventListener("visibilitychange", at);
+		}, st = () => {
+			window.removeEventListener("blur", it), document.removeEventListener("visibilitychange", at);
+		};
+		return he(x, (e) => {
+			if (e) {
+				ot();
+				return;
+			}
+			st();
+		}), he(() => [y.disabled, Ne.value], ([e, t]) => {
+			(e || !t) && J();
+		}), ge(() => {
+			Ae.reject("STooltip не рендерит public wrapper; используйте props и default trigger slot. STooltip renders no public wrapper; use props and the default trigger slot.");
+			for (let [e, t] of [["showDelay", y.showDelay], ["hideDelay", y.hideDelay]]) if (!Number.isSafeInteger(t) || t < 0 || t > 6e4) throw b(`${e} должен быть целым числом миллисекунд от 0 до 60000. ${e} must be an integer number of milliseconds from 0 through 60000.`);
+			s("STooltip", "position", y.position, [
+				"top",
+				"bottom",
+				"left",
+				"right"
+			]), o("STooltip", "disabled", y.disabled);
+		}), de(() => {
+			if (E !== null && (D !== null || O !== null)) throw b("combined trigger нельзя смешивать со split trigger. combined trigger cannot be mixed with a split trigger.");
+			if (E === null && (D === null || O === null)) throw b("default slot обязан применить combined trigger либо обе половины split trigger: focusOwner и pointerTarget. The default slot must apply the combined trigger or both split trigger bindings: focusOwner and pointerTarget.");
+			if (E !== null) {
+				let e = l("STooltip: trigger", E);
+				Z(e), Q(e);
+				return;
+			}
+			if (D === null || O === null) throw b("split trigger требует focusOwner и pointerTarget. A split trigger requires focusOwner and pointerTarget.");
+			Z(l("STooltip: focusOwner", D)), Q(l("STooltip: pointerTarget", O));
+		}), ue(() => {
+			J(), E = null, D = null, O = null, k = null, A = null, G.value = null, st();
+		}), (e, t) => (h(), p(u, null, [pe(e.$slots, "default", {
+			trigger: tt.value,
+			focusOwner: nt.value,
+			pointerTarget: rt.value,
+			isOpen: x.value
+		}), (h(), ae(re, { to: "body" }, [se(ie, {
+			"enter-active-class": "transition-opacity duration-[var(--s-motion-fast)]",
+			"enter-from-class": "opacity-0",
+			"leave-active-class": "transition-opacity duration-[var(--s-motion-fast)]",
+			"leave-from-class": "opacity-100",
+			"leave-to-class": "opacity-0"
+		}, {
+			default: _e(() => [x.value ? (h(), p("div", {
+				key: 0,
+				id: P,
+				ref_key: "tooltipRef",
+				ref: Re,
+				class: "s-tooltip",
+				"data-placement": v(Ve),
+				style: le(v(ze)),
+				role: "tooltip"
+			}, [m("div", ye, [
+				V.value ? (h(), p("strong", be, _(V.value), 1)) : f("", !0),
+				H.value ? (h(), p("p", xe, _(H.value), 1)) : f("", !0),
+				B.value ? (h(), p("div", Se, _(B.value), 1)) : f("", !0),
+				U.value.length > 0 ? (h(), p("dl", Ce, [(h(!0), p(u, null, g(U.value, (e) => (h(), p("div", {
+					key: e.id,
+					class: "s-tooltip__detail"
+				}, [m("dt", we, _(e.label), 1), m("dd", {
+					class: "s-tooltip__detail-value",
+					"data-presentation": e.presentation ?? "text",
+					"data-s-tone": Ie(e.tone)["data-s-tone"]
+				}, [e.presentation === "badge" ? (h(), ae(ne, {
+					key: 0,
+					size: "xs",
+					severity: Fe(e.tone)
+				}, {
+					default: _e(() => [oe(_(e.value), 1)]),
+					_: 2
+				}, 1032, ["severity"])) : (h(), p(u, { key: 1 }, [oe(_(e.value), 1)], 64))], 8, Te)]))), 128))])) : f("", !0),
+				W.value.length > 0 ? (h(), p("div", Ee, [(h(!0), p(u, null, g(W.value, (e) => (h(), p("section", {
+					key: e.id,
+					class: "s-tooltip__section"
+				}, [
+					m("strong", De, _(e.title), 1),
+					e.description ? (h(), p("p", Oe, _(e.description), 1)) : f("", !0),
+					e.items?.length ? (h(), p("ul", ke, [(h(!0), p(u, null, g(e.items, (e) => (h(), p("li", { key: e.id }, _(e.label), 1))), 128))])) : f("", !0)
+				]))), 128))])) : f("", !0)
+			]), m("div", {
+				class: "s-tooltip-arrow",
+				style: le(v(Be))
+			}, null, 4)], 12, ve)) : f("", !0)]),
+			_: 1
+		})]))], 64));
+	}
+});
+//#endregion
+export { y as default };

package/dist/src/components/shared/data-display/STooltipAnchor.vue.d.ts

@@ -0,0 +1,54 @@
+import { VNodeChild } from 'vue';
+import { InteractiveElementApi } from '../../../internal/interactiveElement';
+export type STooltipAnchorShape = 'default' | 'pill' | 'circle';
+export type STooltipAnchorTag = 'span' | 'div';
+export type STooltipAnchorWidth = 'auto' | 'full';
+export type STooltipAnchorElement = HTMLSpanElement | HTMLDivElement;
+export type STooltipAnchorApi = InteractiveElementApi<STooltipAnchorElement>;
+/**
+ * Focus owner для tooltip над пассивным содержимым или недоступным control.
+ * Focus owner for a tooltip around passive content or an unavailable control.
+ */
+export interface Props {
+    /** Доступное имя самостоятельной focus-точки. / Accessible name of the standalone focus target. */
+    accessibleLabel: string;
+    /** Валидный intrinsic root для inline или flow-content composition. / Valid intrinsic root for inline or flow-content composition. */
+    as?: STooltipAnchorTag;
+    /** Геометрия принадлежащего компоненту focus ring. / Geometry of the component-owned focus ring. */
+    shape?: STooltipAnchorShape;
+    /** Строчный или заполняющий layout-контракт. / Inline or fill layout contract. */
+    width?: STooltipAnchorWidth;
+}
+type __VLS_Slots = {
+    /** Пассивное содержимое или disabled control без собственной tab-stop. / Passive content or a disabled control without its own tab stop. */
+    default: () => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, STooltipAnchorApi, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focusin: (event: FocusEvent) => any;
+    focusout: (event: FocusEvent) => any;
+    pointercancel: (event: PointerEvent) => any;
+    pointerdown: (event: PointerEvent) => any;
+    pointerenter: (event: PointerEvent) => any;
+    pointerleave: (event: PointerEvent) => any;
+    pointerup: (event: PointerEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onFocusin?: ((event: FocusEvent) => any) | undefined;
+    onFocusout?: ((event: FocusEvent) => any) | undefined;
+    onPointercancel?: ((event: PointerEvent) => any) | undefined;
+    onPointerdown?: ((event: PointerEvent) => any) | undefined;
+    onPointerenter?: ((event: PointerEvent) => any) | undefined;
+    onPointerleave?: ((event: PointerEvent) => any) | undefined;
+    onPointerup?: ((event: PointerEvent) => any) | undefined;
+}>, {
+    width: STooltipAnchorWidth;
+    shape: STooltipAnchorShape;
+    as: STooltipAnchorTag;
+}, {}, {}, {}, 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/data-display/STooltipAnchor.vue.js

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

package/dist/src/components/shared/data-display/STooltipAnchor.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,73 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { validateExactString as t, validateNonEmptyString as n } from "../../../internal/runtimeContract.js";
+import { useInteractiveLeafRegistration as r } from "../../../internal/passiveContentContract.js";
+import { computed as i, createBlock as a, defineComponent as o, mergeProps as s, openBlock as c, ref as l, renderSlot as u, resolveDynamicComponent as d, unref as f, useSlots as p, withCtx as m } from "vue";
+//#region src/components/shared/data-display/STooltipAnchor.vue?vue&type=script&setup=true&lang.ts
+var h = /*@__PURE__*/ o({
+	name: "STooltipAnchor",
+	inheritAttrs: !1,
+	__name: "STooltipAnchor",
+	props: {
+		accessibleLabel: {},
+		as: { default: "span" },
+		shape: { default: "default" },
+		width: { default: "auto" }
+	},
+	emits: [
+		"focusin",
+		"focusout",
+		"pointerenter",
+		"pointerleave",
+		"pointerdown",
+		"pointerup",
+		"pointercancel"
+	],
+	setup(o, { expose: h, emit: g }) {
+		let _ = o, v = g;
+		if (!p().default) throw Error("STooltipAnchor: default slot обязателен. / STooltipAnchor: the default slot is required.");
+		let y = l(null), b = e({
+			component: "STooltipAnchor",
+			owner: "focusable tooltip anchor"
+		}), x = i(() => n("STooltipAnchor", "accessibleLabel", _.accessibleLabel)), S = i(() => t("STooltipAnchor", "as", _.as, ["span", "div"])), C = i(() => S.value === "span" ? "span" : "div"), w = i(() => t("STooltipAnchor", "shape", _.shape, [
+			"default",
+			"pill",
+			"circle"
+		])), T = i(() => t("STooltipAnchor", "width", _.width, ["auto", "full"]));
+		r({ owner: "STooltipAnchor" });
+		let E = () => {
+			let e = y.value;
+			if (!e) throw Error("STooltipAnchor: native anchor element is unavailable");
+			return e;
+		};
+		return h({
+			getElement: E,
+			focus: (e) => E().focus(e)
+		}), (e, t) => (c(), a(d(C.value), s({
+			ref_key: "anchorRef",
+			ref: y
+		}, f(b).bindings(), {
+			class: "s-tooltip-anchor",
+			"data-shape": w.value,
+			"data-width": T.value,
+			role: "group",
+			tabindex: "0",
+			"aria-label": x.value,
+			onFocusin: t[0] ||= (e) => v("focusin", e),
+			onFocusout: t[1] ||= (e) => v("focusout", e),
+			onPointerenter: t[2] ||= (e) => v("pointerenter", e),
+			onPointerleave: t[3] ||= (e) => v("pointerleave", e),
+			onPointerdown: t[4] ||= (e) => v("pointerdown", e),
+			onPointerup: t[5] ||= (e) => v("pointerup", e),
+			onPointercancel: t[6] ||= (e) => v("pointercancel", e)
+		}), {
+			default: m(() => [u(e.$slots, "default", {}, void 0, !0)]),
+			_: 3
+		}, 16, [
+			"data-shape",
+			"data-width",
+			"aria-label"
+		]));
+	}
+});
+//#endregion
+export { h as default };

package/dist/src/components/shared/data-display/STooltipTarget.vue.d.ts

@@ -0,0 +1,41 @@
+import { VNodeChild } from 'vue';
+import { ElementApi } from '../../../internal/interactiveElement';
+export type STooltipTargetTag = 'span' | 'kbd';
+export type STooltipTargetAppearance = 'plain' | 'keycap';
+export type STooltipTargetSize = 'xs' | 'sm' | 'md';
+export type STooltipTargetApi = ElementApi<HTMLElement>;
+/**
+ * Пассивная pointer/geometry target для split-контракта STooltip.
+ * Passive pointer and geometry target for the STooltip split contract.
+ */
+export interface Props {
+    /** Семантический HTML root без собственной интерактивности. / Semantic HTML root without its own interactivity. */
+    as?: STooltipTargetTag;
+    /** Нейтральная или keycap presentation. / Plain or keycap presentation. */
+    appearance?: STooltipTargetAppearance;
+    /** Централизованная visual density target. / Centralized visual density of the target. */
+    size?: STooltipTargetSize;
+}
+type __VLS_Slots = {
+    /** Пассивное содержимое target. / Passive target content. */
+    default: () => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, STooltipTargetApi, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    pointerenter: (event: PointerEvent) => any;
+    pointerleave: (event: PointerEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onPointerenter?: ((event: PointerEvent) => any) | undefined;
+    onPointerleave?: ((event: PointerEvent) => any) | undefined;
+}>, {
+    size: STooltipTargetSize;
+    appearance: STooltipTargetAppearance;
+    as: STooltipTargetTag;
+}, {}, {}, {}, 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/data-display/STooltipTarget.vue.js

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