@pgcorp/ui-kit 0.10.0 → 0.10.2

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

@@ -0,0 +1,318 @@
+import { mergeIdReferences as e, useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { resolveOptionalDomId as n, validateExactString as r } from "../../../internal/runtimeContract.js";
+import { useInteractiveLeafRegistration as i } from "../../../internal/passiveContentContract.js";
+import a from "./SButton.vue.js";
+import o from "./SField.vue.js";
+import { resolveFieldSurfaceBindings as s } from "../../../internal/fieldSurface.js";
+import { computed as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createVNode as p, defineComponent as m, mergeProps as h, openBlock as g, ref as _, resolveDynamicComponent as v, toDisplayString as y, unref as b, useId as x, watchEffect as S, withCtx as C } from "vue";
+//#region src/components/shared/controls/SInputText.vue?vue&type=script&setup=true&lang.ts
+var w = [
+	"data-input-family",
+	"data-trailing",
+	"data-with-label"
+], T = { class: "s-input-control" }, E = [
+	"id",
+	"name",
+	"type",
+	"data-size",
+	"data-density",
+	"data-appearance",
+	"value",
+	"placeholder",
+	"autocomplete",
+	"autocapitalize",
+	"autocorrect",
+	"spellcheck",
+	"disabled",
+	"readonly",
+	"required",
+	"aria-invalid",
+	"aria-describedby"
+], D = ["data-kind"], O = {
+	key: 0,
+	class: "s-input-trailing__passive",
+	"aria-hidden": "true"
+}, k = {
+	key: 1,
+	class: "s-input-trailing__text",
+	"aria-hidden": "true"
+}, A = /*@__PURE__*/ m({
+	inheritAttrs: !1,
+	__name: "SInputText",
+	props: {
+		modelValue: { default: "" },
+		modelModifiers: { default: () => ({}) },
+		label: { default: void 0 },
+		placeholder: { default: void 0 },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		monospace: {
+			type: Boolean,
+			default: !1
+		},
+		size: { default: "md" },
+		density: { default: "default" },
+		appearance: { default: "field" },
+		invalid: {
+			type: Boolean,
+			default: !1
+		},
+		errorMessage: { default: void 0 },
+		helpText: { default: void 0 },
+		id: { default: void 0 },
+		name: { default: void 0 },
+		type: { default: "text" },
+		trailingIcon: { default: void 0 },
+		trailingText: { default: void 0 },
+		trailingAction: { default: void 0 },
+		autocomplete: { default: void 0 },
+		autocapitalize: { default: void 0 },
+		autocorrect: { default: void 0 },
+		spellcheck: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"trailing-action",
+		"focus",
+		"click",
+		"keydown"
+	],
+	setup(m, { expose: A, emit: j }) {
+		let M = [
+			"text",
+			"search",
+			"password",
+			"email",
+			"tel",
+			"url",
+			"number",
+			"date",
+			"datetime-local",
+			"month",
+			"time",
+			"week"
+		], N = {
+			text: {
+				family: "textual",
+				type: "text"
+			},
+			search: {
+				family: "textual",
+				type: "search"
+			},
+			password: {
+				family: "textual",
+				type: "password"
+			},
+			email: {
+				family: "textual",
+				type: "email"
+			},
+			tel: {
+				family: "textual",
+				type: "tel"
+			},
+			url: {
+				family: "textual",
+				type: "url"
+			},
+			number: {
+				family: "numeric",
+				type: "number"
+			},
+			date: {
+				family: "temporal",
+				type: "date"
+			},
+			"datetime-local": {
+				family: "temporal",
+				type: "datetime-local"
+			},
+			month: {
+				family: "temporal",
+				type: "month"
+			},
+			time: {
+				family: "temporal",
+				type: "time"
+			},
+			week: {
+				family: "temporal",
+				type: "week"
+			}
+		}, P = m, F = j, I = t({
+			component: "SInputText",
+			owner: "native input"
+		});
+		i({ owner: "SInputText" });
+		let L = _(null);
+		A({
+			focus: () => L.value?.focus(),
+			getElement: () => {
+				let e = L.value;
+				if (!e) throw Error("SInputText: native input element is unavailable");
+				return e;
+			}
+		});
+		let R = x(), z = c(() => n("SInputText", "id", P.id, `s-input-text-${R}`)), B = c(() => {
+			let e = r("SInputText", "type", P.type, M);
+			return N[e];
+		}), V = c(() => r("SInputText", "size", P.size, [
+			"sm",
+			"md",
+			"lg"
+		])), H = c(() => r("SInputText", "appearance", P.appearance, [
+			"field",
+			"grid-cell",
+			"workbench-title"
+		])), U = c(() => {
+			let e = P.modelModifiers;
+			if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError("SInputText: modelModifiers должен быть object. / SInputText: modelModifiers must be an object.");
+			let t = e, n = /* @__PURE__ */ new Set([
+				"trim",
+				"lazy",
+				"number"
+			]), r = Object.keys(t).filter((e) => !n.has(e));
+			if (r.length > 0) throw Error(`SInputText: modelModifiers содержит неизвестные поля ${r.join(", ")}. / SInputText: modelModifiers contains unknown fields ${r.join(", ")}.`);
+			for (let e of n) if (t[e] !== void 0 && typeof t[e] != "boolean") throw TypeError(`SInputText: modelModifiers.${e} должен быть boolean. / SInputText: modelModifiers.${e} must be boolean.`);
+			if (t.number === !0) throw Error("SInputText: modifier number несовместим со строковым modelValue; используйте числовой UI-kit control с числовой моделью. / SInputText: the number modifier is incompatible with string modelValue; use a numeric UI-kit control with a numeric model.");
+			return {
+				trim: t.trim === !0,
+				lazy: t.lazy === !0
+			};
+		});
+		function W(e) {
+			return s("SInputText", {
+				kind: "text-input",
+				appearance: H.value === "field" ? "field" : "embedded",
+				invalid: e.invalid,
+				disabled: e.disabled,
+				readonly: e.readonly
+			});
+		}
+		let G = c(() => {
+			if (P.trailingIcon) return "icon";
+			if (P.trailingText !== void 0) return "text";
+			if (P.trailingAction) return "action";
+		});
+		S(() => {
+			if (U.value, [
+				P.trailingIcon,
+				P.trailingText,
+				P.trailingAction
+			].filter((e) => e !== void 0).length > 1) throw Error("SInputText: trailingIcon, trailingText и trailingAction взаимоисключающие");
+			if (P.trailingText !== void 0 && P.trailingText.length === 0) throw Error("SInputText: trailingText не может быть пустым");
+			if (P.trailingAction && P.trailingAction.label.trim().length === 0) throw Error("SInputText: trailingAction.label обязателен");
+		});
+		function K(e) {
+			let t = e.target;
+			if (!(t instanceof HTMLInputElement)) throw TypeError("SInputText: input/change event target должен быть HTMLInputElement");
+			let n = U.value.trim ? t.value.trim() : t.value;
+			F("update:modelValue", n);
+		}
+		function q(e) {
+			U.value.lazy || K(e);
+		}
+		function J(e) {
+			U.value.lazy && K(e);
+		}
+		return (t, n) => (g(), d("div", {
+			class: "s-input-text-wrapper",
+			"data-input-family": B.value.family,
+			"data-trailing": G.value,
+			"data-with-label": !!m.label || void 0
+		}, [p(o, {
+			"control-id": z.value,
+			label: m.label,
+			required: m.required,
+			"help-text": m.helpText,
+			"error-message": m.errorMessage,
+			invalid: m.invalid,
+			disabled: m.disabled,
+			readonly: m.readonly
+		}, {
+			default: C((t) => [f("div", T, [f("input", h({
+				...b(I).bindings(),
+				...W(t)
+			}, {
+				id: t.controlId,
+				name: m.name,
+				ref_key: "inputRef",
+				ref: L,
+				type: B.value.type,
+				class: ["s-input-text", { "s-input-text--monospace": m.monospace }],
+				"data-size": V.value,
+				"data-density": m.density,
+				"data-appearance": H.value,
+				value: m.modelValue,
+				placeholder: m.placeholder,
+				autocomplete: m.autocomplete,
+				autocapitalize: m.autocapitalize,
+				autocorrect: m.autocorrect,
+				spellcheck: m.spellcheck,
+				disabled: t.disabled,
+				readonly: t.readonly,
+				required: t.required,
+				"aria-invalid": t.invalid || void 0,
+				"aria-describedby": b(e)(b(I).string("aria-describedby"), t.describedBy),
+				onInput: q,
+				onChange: J,
+				onFocus: n[0] ||= (e) => F("focus", e),
+				onClick: n[1] ||= (e) => F("click", e),
+				onKeydown: n[2] ||= (e) => F("keydown", e)
+			}), null, 16, E), G.value ? (g(), d("div", {
+				key: 0,
+				class: "s-input-trailing",
+				"data-kind": G.value
+			}, [m.trailingIcon ? (g(), d("span", O, [(g(), l(v(m.trailingIcon), { class: "s-input-trailing__icon" }))])) : m.trailingText === void 0 ? m.trailingAction ? (g(), l(a, {
+				key: 2,
+				label: "",
+				size: "sm",
+				density: m.density,
+				appearance: "ghost",
+				shape: "square",
+				"icon-only": "",
+				severity: m.trailingAction.severity ?? "secondary",
+				"leading-icon": m.trailingAction.icon,
+				loading: m.trailingAction.loading,
+				disabled: t.disabled || m.trailingAction.disabled,
+				title: m.trailingAction.title ?? m.trailingAction.label,
+				"aria-label": m.trailingAction.label,
+				onClick: n[3] ||= (e) => F("trailing-action", e)
+			}, null, 8, [
+				"density",
+				"severity",
+				"leading-icon",
+				"loading",
+				"disabled",
+				"title",
+				"aria-label"
+			])) : u("", !0) : (g(), d("span", k, y(m.trailingText), 1))], 8, D)) : u("", !0)])]),
+			_: 1
+		}, 8, [
+			"control-id",
+			"label",
+			"required",
+			"help-text",
+			"error-message",
+			"invalid",
+			"disabled",
+			"readonly"
+		])], 8, w));
+	}
+});
+//#endregion
+export { A as default };

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

@@ -0,0 +1,84 @@
+import { VNodeChild } from 'vue';
+import { RouteLocationRaw } from 'vue-router';
+import { STooltipTriggerBinding } from '../data-display/STooltip.vue';
+export type InteractiveSurfaceTone = 'default' | 'primary' | 'success' | 'danger';
+export type InteractiveSurfaceDensity = 'compact' | 'comfortable';
+export type InteractiveSurfacePadding = 'none' | 'sm' | 'md';
+export type InteractiveSurfaceRadius = 'md' | 'lg' | 'xl';
+export type InteractiveSurfaceFill = 'content' | 'container';
+export type InteractiveSurfaceAppearance = 'card' | 'plain' | 'bare';
+export type InteractiveSurfaceActionsLayout = 'responsive' | 'inline' | 'stacked';
+/**
+ * Единственный semantic-контракт поверхности: passive, action или ровно одна link-target.
+ * The sole surface semantics contract: passive, action, or exactly one link target.
+ */
+export type InteractiveSurfaceContract = {
+    readonly mode: 'static';
+} | {
+    readonly mode: 'action';
+    readonly accessibleLabel: string;
+    readonly disabled?: boolean;
+    readonly pressed?: boolean;
+} | ({
+    readonly mode: 'link';
+    readonly accessibleLabel: string;
+    readonly disabled?: boolean;
+    readonly target?: '_self' | '_blank' | '_parent' | '_top';
+    readonly rel?: string;
+} & ({
+    readonly href: string;
+    readonly to?: never;
+} | {
+    readonly href?: never;
+    readonly to: RouteLocationRaw;
+}));
+/** Разрешённые semantic-режимы поверхности. / Supported semantic surface modes. */
+export type InteractiveSurfaceMode = InteractiveSurfaceContract['mode'];
+/**
+ * Контракт большой интерактивной поверхности с пассивным содержимым.
+ * Contract for a large interactive surface whose visual content remains passive.
+ */
+export interface Props {
+    surface: InteractiveSurfaceContract;
+    selected?: boolean;
+    tone?: InteractiveSurfaceTone;
+    density?: InteractiveSurfaceDensity;
+    padding?: InteractiveSurfacePadding;
+    radius?: InteractiveSurfaceRadius;
+    fill?: InteractiveSurfaceFill;
+    appearance?: InteractiveSurfaceAppearance;
+    actionsLayout?: InteractiveSurfaceActionsLayout;
+    contentAlign?: 'start' | 'center';
+    /** Полный binding явного STooltip trigger, направляемый на activation owner. / Complete explicit STooltip trigger binding routed to the activation owner. */
+    tooltipTrigger?: STooltipTriggerBinding;
+}
+type __VLS_Slots = {
+    /** Пассивное flow-содержимое поверхности. / Passive flow content of the surface. */
+    default?: () => VNodeChild;
+    /** Sibling controls inside the same visual chrome and outside the primary activation owner. */
+    actions?: () => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    activate: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onActivate?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    selected: boolean;
+    fill: InteractiveSurfaceFill;
+    radius: InteractiveSurfaceRadius;
+    tone: InteractiveSurfaceTone;
+    density: InteractiveSurfaceDensity;
+    contentAlign: "start" | "center";
+    appearance: InteractiveSurfaceAppearance;
+    actionsLayout: InteractiveSurfaceActionsLayout;
+    padding: InteractiveSurfacePadding;
+    tooltipTrigger: STooltipTriggerBinding;
+}, {}, {}, {}, 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/SInteractiveSurface.vue.js

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

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

@@ -0,0 +1,239 @@
+import { hasOwn as e } from "../../../internal/es2020.js";
+import { useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { resolveSemanticToneBinding as n } from "../../../internal/semanticTone.js";
+import { PassiveContentBoundary as r, useInteractiveLeafRegistration as i } from "../../../internal/passiveContentContract.js";
+import { resolveLinkTarget as a } from "../../../internal/linkTarget.js";
+import { computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, createVNode as d, defineComponent as f, mergeProps as p, openBlock as m, renderSlot as h, resolveDynamicComponent as g, toDisplayString as _, unref as v, useSlots as y, watchEffect as b, withCtx as x } from "vue";
+import { RouterLink as S } from "vue-router";
+//#region src/components/shared/controls/SInteractiveSurface.vue?vue&type=script&setup=true&lang.ts
+var C = [
+	"data-s-tone",
+	"data-mode",
+	"data-density",
+	"data-padding",
+	"data-radius",
+	"data-fill",
+	"data-appearance",
+	"data-actions-layout",
+	"data-has-actions",
+	"data-selected",
+	"data-pressed",
+	"data-disabled",
+	"data-content-align"
+], w = { class: "s-interactive-surface__layout" }, T = { class: "s-interactive-surface__primary" }, E = [
+	"disabled",
+	"aria-label",
+	"aria-pressed"
+], D = { class: "s-interactive-surface__accessible-label" }, O = { class: "s-interactive-surface__accessible-label" }, k = {
+	class: "s-interactive-surface__content",
+	"data-passive-content": ""
+}, A = {
+	key: 0,
+	class: "s-interactive-surface__actions"
+}, j = /*@__PURE__*/ f({
+	inheritAttrs: !1,
+	__name: "SInteractiveSurface",
+	props: {
+		surface: {},
+		selected: {
+			type: Boolean,
+			default: !1
+		},
+		tone: { default: "default" },
+		density: { default: "comfortable" },
+		padding: { default: "md" },
+		radius: { default: "lg" },
+		fill: { default: "content" },
+		appearance: { default: "card" },
+		actionsLayout: { default: "inline" },
+		contentAlign: { default: "start" },
+		tooltipTrigger: { default: void 0 }
+	},
+	emits: ["activate"],
+	setup(f, { emit: j }) {
+		let M = [
+			"default",
+			"primary",
+			"success",
+			"danger"
+		], N = f, P = j, F = y(), I = t({
+			component: "SInteractiveSurface",
+			owner: "interactive surface owner"
+		}), L = o(() => n("SInteractiveSurface", "tone", N.tone, M)), R = (e, t) => {
+			if (e[t] !== void 0 && typeof e[t] != "boolean") throw TypeError(`SInteractiveSurface: surface.${t} должен быть boolean`);
+		}, z = (e, t) => {
+			let n = new Set(t), r = Object.keys(e).filter((e) => !n.has(e));
+			if (r.length > 0) throw Error(`SInteractiveSurface: surface mode="${String(e.mode)}" не допускает поля ${r.join(", ")}`);
+		}, B = o(() => {
+			let e = N.surface;
+			if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError("SInteractiveSurface: surface должен быть discriminated object");
+			let t = e;
+			if (t.mode === "static") return z(t, ["mode"]), { mode: "static" };
+			if (t.mode === "action") {
+				if (z(t, [
+					"mode",
+					"accessibleLabel",
+					"disabled",
+					"pressed"
+				]), R(t, "disabled"), R(t, "pressed"), typeof t.accessibleLabel != "string" || !t.accessibleLabel.trim()) throw TypeError("SInteractiveSurface: accessibleLabel обязателен для mode=\"action\"");
+				return {
+					mode: "action",
+					accessibleLabel: t.accessibleLabel,
+					disabled: t.disabled,
+					pressed: t.pressed
+				};
+			}
+			if (t.mode === "link") {
+				if (z(t, [
+					"mode",
+					"accessibleLabel",
+					"disabled",
+					"target",
+					"rel",
+					"href",
+					"to"
+				]), R(t, "disabled"), typeof t.accessibleLabel != "string" || !t.accessibleLabel.trim()) throw TypeError("SInteractiveSurface: accessibleLabel обязателен для mode=\"link\"");
+				let e = t.target ?? "_self";
+				if (![
+					"_self",
+					"_blank",
+					"_parent",
+					"_top"
+				].includes(String(e))) throw TypeError("SInteractiveSurface: surface.target имеет недопустимое значение");
+				if (t.rel !== void 0 && typeof t.rel != "string") throw TypeError("SInteractiveSurface: surface.rel должен быть string");
+				if ("href" in t && (typeof t.href != "string" || t.href.length === 0)) throw TypeError("SInteractiveSurface: surface.href должен быть непустой string");
+				if ("to" in t && !(typeof t.to == "string" || typeof t.to == "object" && t.to !== null && !Array.isArray(t.to))) throw TypeError("SInteractiveSurface: surface.to должен быть RouteLocationRaw");
+				let n = a({
+					href: typeof t.href == "string" ? t.href : void 0,
+					to: t.to,
+					target: e,
+					rel: t.rel,
+					owner: "SInteractiveSurface"
+				});
+				return n.kind === "anchor" ? {
+					mode: "link",
+					accessibleLabel: t.accessibleLabel,
+					disabled: t.disabled,
+					href: n.bindings.href,
+					target: n.bindings.target,
+					rel: n.bindings.rel
+				} : {
+					mode: "link",
+					accessibleLabel: t.accessibleLabel,
+					disabled: t.disabled,
+					to: n.bindings.to,
+					target: n.bindings.target,
+					rel: n.bindings.rel
+				};
+			}
+			throw TypeError(`SInteractiveSurface: неизвестный surface.mode "${String(t.mode)}"`);
+		}), V = [
+			"ref",
+			"aria-describedby",
+			"onPointerenter",
+			"onPointerleave",
+			"onPointerdown",
+			"onPointerup",
+			"onPointercancel",
+			"onFocusin",
+			"onFocusout"
+		], H = o(() => {
+			let t = N.tooltipTrigger;
+			if (t === void 0) return;
+			if (typeof t != "object" || !t || Array.isArray(t)) throw TypeError("SInteractiveSurface: tooltipTrigger должен быть полным STooltip trigger binding. / SInteractiveSurface: tooltipTrigger must be a complete STooltip trigger binding.");
+			let n = t, r = Object.keys(n).filter((e) => !V.includes(e)), i = V.filter((t) => !e(n, t));
+			if (r.length > 0 || i.length > 0) throw Error(`SInteractiveSurface: tooltipTrigger имеет недопустимый набор ключей; missing=${i.join(",")}; unexpected=${r.join(",")}. / SInteractiveSurface: tooltipTrigger has an invalid key set; missing=${i.join(",")}; unexpected=${r.join(",")}.`);
+			if (n["aria-describedby"] !== void 0 && typeof n["aria-describedby"] != "string") throw TypeError("SInteractiveSurface: tooltipTrigger aria-describedby должен быть string или undefined. / SInteractiveSurface: tooltipTrigger aria-describedby must be a string or undefined.");
+			if (typeof n.ref != "function") throw TypeError("SInteractiveSurface: tooltipTrigger.ref должен быть callback ref. / SInteractiveSurface: tooltipTrigger.ref must be a callback ref.");
+			for (let e of V) if (e !== "ref" && e !== "aria-describedby" && typeof n[e] != "function") throw TypeError(`SInteractiveSurface: tooltipTrigger.${e} должен быть function. / SInteractiveSurface: tooltipTrigger.${e} must be a function.`);
+			return t;
+		}), U = () => ({
+			...I.bindings(),
+			...H.value ?? {}
+		}), W = o(() => B.value.mode), G = o(() => B.value.mode === "static" ? !1 : B.value.disabled ?? !1), K = o(() => B.value.mode === "action" ? B.value.pressed : void 0), q = o(() => {
+			let e = B.value;
+			return e.mode === "link" ? a({
+				href: e.href,
+				to: e.to,
+				target: e.target ?? "_self",
+				rel: e.rel,
+				owner: "SInteractiveSurface"
+			}) : null;
+		}), J = o(() => q.value?.kind === "router" ? S : "a"), Y = () => {
+			let e = q.value;
+			if (!e) throw Error("SInteractiveSurface: link bindings requested outside link surface");
+			return {
+				...U(),
+				...e.bindings
+			};
+		}, X = o(() => {
+			if (B.value.mode !== "static") return B.value.accessibleLabel.trim();
+		});
+		b(() => {
+			if (B.value.mode === "static" && H.value) throw Error("SInteractiveSurface: tooltipTrigger требует action или link surface. / SInteractiveSurface: tooltipTrigger requires an action or link surface.");
+			H.value;
+		}), i({
+			owner: "SInteractiveSurface",
+			active: () => W.value !== "static"
+		});
+		let Z = {
+			owner: "SInteractiveSurface",
+			region: "passive content-region",
+			active: () => W.value !== "static",
+			guidance: "Передайте дополнительное действие через sibling action-region. / Put the additional action in the sibling action region."
+		};
+		function Q(e) {
+			if (G.value) {
+				e.preventDefault();
+				return;
+			}
+			P("activate", e);
+		}
+		function $(e) {
+			P("activate", e);
+		}
+		return (e, t) => (m(), l("div", p(W.value === "static" ? v(I).bindings() : void 0, {
+			"data-s-tone": L.value["data-s-tone"],
+			class: "s-interactive-surface",
+			"data-mode": W.value,
+			"data-density": f.density,
+			"data-padding": f.padding,
+			"data-radius": f.radius,
+			"data-fill": f.fill,
+			"data-appearance": f.appearance,
+			"data-actions-layout": f.actionsLayout,
+			"data-has-actions": !!F.actions || void 0,
+			"data-selected": f.selected || void 0,
+			"data-pressed": K.value,
+			"data-disabled": G.value || void 0,
+			"data-content-align": f.contentAlign
+		}), [u("div", w, [u("div", T, [W.value === "action" ? (m(), l("button", p({ key: 0 }, U(), {
+			class: "s-interactive-surface__activation",
+			type: "button",
+			disabled: G.value,
+			"aria-label": X.value,
+			"aria-pressed": K.value,
+			onClick: $
+		}), [u("span", D, _(X.value), 1)], 16, E)) : W.value === "link" ? (m(), s(g(J.value), p({ key: 1 }, Y(), {
+			class: "s-interactive-surface__activation",
+			"aria-label": X.value,
+			"aria-current": f.selected ? "page" : void 0,
+			"aria-disabled": G.value || void 0,
+			tabindex: G.value ? -1 : void 0,
+			onClick: Q
+		}), {
+			default: x(() => [u("span", O, _(X.value), 1)]),
+			_: 1
+		}, 16, [
+			"aria-label",
+			"aria-current",
+			"aria-disabled",
+			"tabindex"
+		])) : c("", !0), u("div", k, [d(v(r), { contract: Z }, {
+			default: x(() => [h(e.$slots, "default", {}, void 0, !0)]),
+			_: 3
+		})])]), e.$slots.actions ? (m(), l("div", A, [h(e.$slots, "actions", {}, void 0, !0)])) : c("", !0)])], 16, C));
+	}
+});
+//#endregion
+export { j as default };