@pgcorp/ui-kit 0.10.0 → 0.10.1

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

@@ -0,0 +1,264 @@
+import { ChevronRight as e } from "../../icons/sputnigUiIcons.js";
+import { useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { resolveSemanticToneBinding as n } from "../../../internal/semanticTone.js";
+import r from "../data-display/SBadge.vue.js";
+import { PassiveContentBoundary as i, useInteractiveLeafRegistration as a } from "../../../internal/passiveContentContract.js";
+import { resolveLinkTarget as o } from "../../../internal/linkTarget.js";
+import { useTreeActionRegistration as s } from "../_internal/treeRuntime.js";
+import c from "../data-display/SProgressIndicator.vue.js";
+import { computed as l, createBlock as u, createCommentVNode as d, createElementBlock as f, createElementVNode as p, createTextVNode as m, createVNode as h, defineComponent as g, getCurrentInstance as _, mergeProps as v, openBlock as y, ref as b, resolveDynamicComponent as x, toDisplayString as S, unref as C, watchEffect as w, withCtx as T } from "vue";
+import { RouterLink as ee } from "vue-router";
+//#region src/components/shared/controls/SButton.vue?vue&type=script&setup=true&lang.ts
+var E = {
+	key: 0,
+	class: "s-button__loader",
+	"aria-hidden": "true"
+}, D = { class: "s-button__content" }, O = ["data-expanded"], k = {
+	key: 2,
+	class: "s-button__label"
+}, A = {
+	key: 4,
+	class: "s-button__badge-slot"
+}, j = {
+	key: 5,
+	class: "s-button__shortcut",
+	"aria-hidden": "true"
+}, M = ["data-expanded"], N = /*@__PURE__*/ g({
+	inheritAttrs: !1,
+	__name: "SButton",
+	props: {
+		label: { default: void 0 },
+		severity: { default: "primary" },
+		size: { default: "md" },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		loading: {
+			type: Boolean,
+			default: !1
+		},
+		loadingLabel: { default: void 0 },
+		leadingIcon: { default: void 0 },
+		trailingIcon: { default: void 0 },
+		iconSize: { default: "default" },
+		density: { default: "default" },
+		spacing: { default: "default" },
+		hoverSurface: { default: "self" },
+		badge: { default: void 0 },
+		badgeSeverity: { default: "secondary" },
+		shortcut: { default: void 0 },
+		iconOnly: {
+			type: Boolean,
+			default: !1
+		},
+		width: { default: "auto" },
+		contentAlign: { default: "center" },
+		appearance: { default: "solid" },
+		shape: { default: "default" },
+		pressed: {
+			type: [Boolean, String],
+			default: void 0
+		},
+		busy: {
+			type: Boolean,
+			default: !1
+		},
+		disclosure: { default: void 0 },
+		href: { default: void 0 },
+		to: { default: void 0 },
+		target: { default: void 0 },
+		rel: { default: void 0 },
+		type: { default: void 0 }
+	},
+	emits: ["click"],
+	setup(g, { expose: N, emit: P }) {
+		let F = [
+			"primary",
+			"secondary",
+			"success",
+			"info",
+			"warn",
+			"danger",
+			"contrast"
+		], I = g, L = P, R = _();
+		if (!R) throw Error("SButton: component instance is unavailable");
+		let z = R.slots, B = () => z.default?.() ?? [], V = b(null), H = t({
+			component: "SButton",
+			owner: "native button"
+		}), U = l(() => n("SButton", "severity", I.severity, F)), W = s({
+			owner: "SButton",
+			element: V,
+			disabled: () => I.disabled || I.loading
+		});
+		a({ owner: "SButton" });
+		let G = l(() => {
+			let e = I.href !== void 0, t = I.to !== void 0;
+			if (e && t) throw TypeError("SButton: передайте не более одного navigation target — href или to");
+			if (!e && !t) return null;
+			if (I.type !== void 0) throw TypeError("SButton: navigation target несовместим с native button type");
+			return o({
+				href: I.href,
+				to: I.to,
+				target: I.target,
+				rel: I.rel,
+				owner: "SButton"
+			});
+		}), K = l(() => I.disabled || I.loading), q = l(() => {
+			let e = G.value;
+			return !e || K.value ? e ? "a" : "button" : e.kind === "router" ? ee : "a";
+		}), J = l(() => {
+			let e = H.bindings(), t = W ? {
+				...e,
+				tabindex: -1
+			} : e, n = I.disclosure ? {
+				...t,
+				"aria-expanded": I.disclosure.expanded,
+				"aria-controls": I.disclosure.controls
+			} : t, r = G.value, i = r === null ? {
+				...n,
+				disabled: I.disabled || I.loading || void 0,
+				type: I.type ?? "button"
+			} : K.value ? {
+				...n,
+				"aria-disabled": !0,
+				tabindex: -1
+			} : {
+				...n,
+				...r.bindings
+			};
+			if (!I.loading) return i;
+			let a = i["aria-label"], o = [
+				I.loadingLabel,
+				I.label,
+				a
+			].find((e) => typeof e == "string" && e.trim().length > 0);
+			if (!o && !z.default) throw Error("SButton: loading action requires label, loadingLabel, or aria-label");
+			return o ? {
+				...i,
+				"aria-label": o
+			} : i;
+		}), Y = {
+			owner: "SButton",
+			region: "passive default content",
+			guidance: "Вынесите независимое действие в соседний SButton. / Move the independent action to a sibling SButton."
+		};
+		w(() => {
+			let e = G.value;
+			if (e && I.pressed !== void 0) throw Error("SButton: navigation target несовместим с pressed toggle semantics");
+			if (e && I.disclosure !== void 0) throw Error("SButton: navigation target несовместим с disclosure trigger semantics");
+			if (I.disclosure && I.disclosure.controls.trim().length === 0) throw Error("SButton: disclosure.controls must be a non-empty id");
+			let t = I.disclosure?.iconPlacement ?? "trailing";
+			if (I.disclosure && (t === "leading" && I.leadingIcon || t === "trailing" && I.trailingIcon)) throw Error(`SButton: disclosure ${t} icon conflicts with the matching icon prop`);
+		});
+		let X = l(() => I.iconOnly || I.label === "" && !!(I.leadingIcon || I.trailingIcon || z.default)), Z = l(() => I.label === void 0 || I.label === "" && !I.leadingIcon && !I.trailingIcon), Q = l(() => I.size === "lg" ? "sm" : "xs");
+		function te(e) {
+			if (e === null) {
+				V.value = null;
+				return;
+			}
+			if (e instanceof HTMLButtonElement || e instanceof HTMLAnchorElement) {
+				V.value = e;
+				return;
+			}
+			let t = Reflect.get(e, "$el");
+			if (!(t instanceof HTMLAnchorElement)) throw TypeError("SButton: RouterLink root must resolve to an HTMLAnchorElement");
+			V.value = t;
+		}
+		function ne(e) {
+			if (G.value && K.value) {
+				e.preventDefault(), e.stopImmediatePropagation();
+				return;
+			}
+			L("click", e);
+		}
+		let $ = () => {
+			let e = V.value;
+			if (!e) throw Error("SButton: interactive element is unavailable");
+			return e;
+		};
+		return N({
+			getElement: $,
+			focus: (e) => $().focus(e)
+		}), (t, n) => (y(), u(x(q.value), v({ ref: te }, J.value, {
+			"data-s-tone": U.value["data-s-tone"],
+			class: "s-button",
+			"data-size": g.size,
+			"data-width": g.width,
+			"data-content-align": g.contentAlign,
+			"data-density": g.density,
+			"data-spacing": g.spacing,
+			"data-hover-surface": g.hoverSurface,
+			"data-icon-only": X.value,
+			"data-icon-size": g.iconSize,
+			"data-appearance": g.appearance,
+			"data-shape": g.shape,
+			"data-loading": g.loading || void 0,
+			"aria-pressed": g.pressed,
+			"aria-busy": g.busy || g.loading || void 0,
+			onClick: ne
+		}), {
+			default: T(() => [g.loading ? (y(), f("span", E, [h(c, {
+				accessibility: { mode: "decorative" },
+				size: Q.value
+			}, null, 8, ["size"])])) : d("", !0), p("span", D, [
+				g.disclosure?.iconPlacement === "leading" ? (y(), f("span", {
+					key: 0,
+					class: "s-button__disclosure-icon s-button__icon s-button__icon--leading",
+					"data-expanded": g.disclosure.expanded,
+					"data-disclosure-icon": "",
+					"aria-hidden": "true"
+				}, [h(C(e))], 8, O)) : g.leadingIcon ? (y(), u(x(g.leadingIcon), {
+					key: 1,
+					class: "s-button__icon s-button__icon--leading",
+					"aria-hidden": "true"
+				})) : d("", !0),
+				g.label ? (y(), f("span", k, S(g.label), 1)) : d("", !0),
+				Z.value ? (y(), u(C(i), {
+					key: 3,
+					contract: Y
+				}, {
+					default: T(() => [(y(), u(x(B)))]),
+					_: 1
+				})) : d("", !0),
+				g.badge === void 0 ? d("", !0) : (y(), f("span", A, [h(r, {
+					severity: g.badgeSeverity,
+					size: "xs"
+				}, {
+					default: T(() => [m(S(g.badge), 1)]),
+					_: 1
+				}, 8, ["severity"])])),
+				g.shortcut ? (y(), f("span", j, S(g.shortcut), 1)) : d("", !0),
+				g.disclosure && g.disclosure.iconPlacement !== "leading" && g.disclosure.iconPlacement !== "none" ? (y(), f("span", {
+					key: 6,
+					class: "s-button__disclosure-icon s-button__icon s-button__icon--trailing",
+					"data-expanded": g.disclosure.expanded,
+					"data-disclosure-icon": "",
+					"aria-hidden": "true"
+				}, [h(C(e))], 8, M)) : g.trailingIcon ? (y(), u(x(g.trailingIcon), {
+					key: 7,
+					class: "s-button__icon s-button__icon--trailing",
+					"aria-hidden": "true"
+				})) : d("", !0)
+			])]),
+			_: 1
+		}, 16, [
+			"data-s-tone",
+			"data-size",
+			"data-width",
+			"data-content-align",
+			"data-density",
+			"data-spacing",
+			"data-hover-surface",
+			"data-icon-only",
+			"data-icon-size",
+			"data-appearance",
+			"data-shape",
+			"data-loading",
+			"aria-pressed",
+			"aria-busy"
+		]));
+	}
+});
+//#endregion
+export { N as default };

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

@@ -0,0 +1,31 @@
+export interface Props {
+    modelValue: boolean;
+    label?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    helpText?: string;
+    errorMessage?: string;
+    id?: string;
+    indeterminate?: boolean;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    required: boolean;
+    label: string;
+    id: string;
+    invalid: boolean;
+    disabled: boolean;
+    indeterminate: boolean;
+    readonly: boolean;
+    helpText: string;
+    errorMessage: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

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

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

@@ -0,0 +1,105 @@
+import { Check as e, Minus as t } from "../../icons/sputnigUiIcons.js";
+import { mergeIdReferences as n, useOwnedAttrs as r } from "../../../internal/ownedAttrs.js";
+import { useInteractiveLeafRegistration as i } from "../../../internal/passiveContentContract.js";
+import { useBinaryInput as a } from "../../../internal/useBinaryInput.js";
+import o from "./SField.vue.js";
+import { createBlock as s, createElementVNode as c, defineComponent as l, mergeProps as u, openBlock as d, resolveDynamicComponent as f, unref as p, withCtx as m, withModifiers as h } from "vue";
+//#region src/components/shared/controls/SCheckbox.vue?vue&type=script&setup=true&lang.ts
+var g = { class: "s-checkbox-control" }, _ = [
+	"id",
+	"checked",
+	"disabled",
+	"required",
+	"aria-invalid",
+	"aria-readonly",
+	"aria-describedby"
+], v = { class: "s-checkbox-box" }, y = /*@__PURE__*/ l({
+	inheritAttrs: !1,
+	__name: "SCheckbox",
+	props: {
+		modelValue: { type: Boolean },
+		label: { default: void 0 },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		invalid: {
+			type: Boolean,
+			default: !1
+		},
+		helpText: { default: void 0 },
+		errorMessage: { default: void 0 },
+		id: { default: void 0 },
+		indeterminate: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["update:modelValue", "click"],
+	setup(l, { emit: y }) {
+		let b = l, x = y, S = r({
+			component: "SCheckbox",
+			owner: "native checkbox input"
+		});
+		i({ owner: "SCheckbox" });
+		let { checkedValue: C, inputId: w, onChange: T, onClick: E, setInputElement: D } = a({
+			owner: "SCheckbox",
+			inputName: "checkbox",
+			props: b,
+			indeterminate: () => b.indeterminate,
+			emitUpdate: (e) => x("update:modelValue", e),
+			emitClick: (e) => x("click", e)
+		});
+		return (r, i) => (d(), s(o, {
+			"control-id": p(w),
+			label: l.label,
+			required: l.required,
+			"help-text": l.helpText,
+			"error-message": l.errorMessage,
+			invalid: l.invalid,
+			disabled: l.disabled,
+			readonly: l.readonly,
+			layout: "inline"
+		}, {
+			default: m((r) => [c("span", g, [c("input", u({ ref: p(D) }, p(S).bindings(), {
+				id: r.controlId,
+				type: "checkbox",
+				class: "s-checkbox-input",
+				checked: p(C),
+				disabled: r.disabled,
+				required: r.required,
+				"aria-invalid": r.invalid || void 0,
+				"aria-readonly": r.readonly || void 0,
+				"aria-describedby": p(n)(p(S).string("aria-describedby"), r.describedBy),
+				onClick: i[0] ||= h((...e) => p(E) && p(E)(...e), ["stop"]),
+				onChange: i[1] ||= (...e) => p(T) && p(T)(...e)
+			}), null, 16, _), c("span", v, [(d(), s(f(l.indeterminate ? p(t) : p(e)), {
+				class: "s-checkbox-check",
+				"aria-hidden": "true",
+				"data-sputnig-ui-icon": l.indeterminate ? "minus" : "check",
+				"data-sputnig-ui-icon-color-mode": "auto",
+				"data-sputnig-ui-icon-set": "classic"
+			}, null, 8, ["data-sputnig-ui-icon"]))])])]),
+			_: 1
+		}, 8, [
+			"control-id",
+			"label",
+			"required",
+			"help-text",
+			"error-message",
+			"invalid",
+			"disabled",
+			"readonly"
+		]));
+	}
+});
+//#endregion
+export { y as default };

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

@@ -0,0 +1,42 @@
+import { SelectionKey, SelectionKey as PublicSelectionKey } from '../_internal/useSelectionRoving';
+import { SFieldGroupColumns, SFieldGroupLayout } from './SFieldGroup.vue';
+/** Одна checkbox option со стабильной domain identity. / One checkbox option with stable domain identity. */
+export interface SCheckboxGroupOption<T extends PublicSelectionKey = PublicSelectionKey> {
+    value: T;
+    label: string;
+    helpText?: string;
+    disabled?: boolean;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends SelectionKey = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<{
+        modelValue: readonly T[];
+        options: readonly SCheckboxGroupOption<T>[];
+        label: string;
+        id?: string;
+        helpText?: string;
+        errorMessage?: string;
+        required?: boolean;
+        invalid?: boolean;
+        disabled?: boolean;
+        readonly?: boolean;
+        layout?: SFieldGroupLayout;
+        columns?: SFieldGroupColumns;
+    } & {
+        "onUpdate:modelValue"?: ((value: readonly T[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", value: readonly T[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

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

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

@@ -0,0 +1,119 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { validateDomId as t, validateNonEmptyString as n } from "../../../internal/runtimeContract.js";
+import { selectionKeyToken as r, validateSelectionIdentities as i } from "../_internal/useSelectionRoving.js";
+import a from "./SCheckbox.vue.js";
+import o from "./SFieldGroup.vue.js";
+import { Fragment as s, computed as c, createBlock as l, createElementBlock as u, defineComponent as d, mergeProps as f, openBlock as p, renderList as m, unref as h, useId as g, withCtx as _ } from "vue";
+//#region src/components/shared/controls/SCheckboxGroup.vue?vue&type=script&setup=true&lang.ts
+var v = /*@__PURE__*/ d({
+	inheritAttrs: !1,
+	__name: "SCheckboxGroup",
+	props: {
+		modelValue: {},
+		options: {},
+		label: {},
+		id: { default: void 0 },
+		helpText: { default: void 0 },
+		errorMessage: { default: void 0 },
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		invalid: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		layout: { default: "stacked" },
+		columns: { default: 1 }
+	},
+	emits: ["update:modelValue"],
+	setup(d, { emit: v }) {
+		let y = d, b = v, x = e({
+			component: "SCheckboxGroup",
+			owner: "field group"
+		}), S = g(), C = c(() => t("SCheckboxGroup", "id", y.id ?? `s-checkbox-group-${S}`)), w = c(() => (i("SCheckboxGroup", y.options.map((e, t) => ({
+			key: e.value,
+			coordinate: `options[${t}].value`
+		}))), y.options.map((e, t) => {
+			n("SCheckboxGroup", `options[${t}].label`, e.label);
+			let i = r("SCheckboxGroup", e.value, `options[${t}].value`);
+			return {
+				option: e,
+				token: i,
+				id: `${C.value}-option-${i}`
+			};
+		}))), T = c(() => new Map(w.value.map((e) => [e.token, e.option.value]))), E = c(() => {
+			let e = i("SCheckboxGroup", y.modelValue.map((e, t) => ({
+				key: e,
+				coordinate: `modelValue[${t}]`
+			}))), t = T.value;
+			for (let [n] of e) if (!t.has(n)) {
+				let e = y.modelValue.findIndex((e) => r("SCheckboxGroup", e, "modelValue") === n);
+				throw Error(`SCheckboxGroup: modelValue[${e}] does not match any option`);
+			}
+			return new Set(e.keys());
+		});
+		function D(e, t) {
+			if (y.readonly || y.disabled) return;
+			let n = r("SCheckboxGroup", e, "updated option value"), i = new Set(E.value);
+			t ? i.add(n) : i.delete(n), b("update:modelValue", w.value.filter((e) => i.has(e.token)).map((e) => e.option.value));
+		}
+		return (e, t) => (p(), l(o, f(h(x).bindings(), {
+			id: C.value,
+			label: d.label,
+			"help-text": d.helpText,
+			"error-message": d.errorMessage,
+			required: d.required,
+			invalid: d.invalid,
+			disabled: d.disabled,
+			readonly: d.readonly,
+			layout: d.layout,
+			columns: d.columns
+		}), {
+			default: _((e) => [(p(!0), u(s, null, m(w.value, (t) => (p(), l(a, {
+				id: t.id,
+				key: t.token,
+				"model-value": E.value.has(t.token),
+				label: t.option.label,
+				"help-text": t.option.helpText,
+				disabled: e.disabled || t.option.disabled,
+				readonly: e.readonly,
+				invalid: e.invalid,
+				"aria-describedby": e.describedBy,
+				"onUpdate:modelValue": (e) => D(t.option.value, e)
+			}, null, 8, [
+				"id",
+				"model-value",
+				"label",
+				"help-text",
+				"disabled",
+				"readonly",
+				"invalid",
+				"aria-describedby",
+				"onUpdate:modelValue"
+			]))), 128))]),
+			_: 1
+		}, 16, [
+			"id",
+			"label",
+			"help-text",
+			"error-message",
+			"required",
+			"invalid",
+			"disabled",
+			"readonly",
+			"layout",
+			"columns"
+		]));
+	}
+});
+//#endregion
+export { v as default };

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

@@ -0,0 +1,52 @@
+import { VNodeChild } from 'vue';
+import { SelectionKey, SelectionKey as PublicSelectionKey } from '../_internal/useSelectionRoving';
+/** Одна radio-card option. / One radio-card option. */
+export interface ChoiceCardOption<T extends PublicSelectionKey = string> {
+    value: T;
+    title: string;
+    description?: string;
+    meta?: string;
+    kicker?: string;
+    disabled?: boolean;
+}
+/** Публичный контракт группы карточек выбора. / Public choice-card group contract. */
+export interface Props<T extends PublicSelectionKey = string> {
+    modelValue: T | null;
+    options: readonly ChoiceCardOption<T>[];
+    label: string;
+    id?: string;
+    helpText?: string;
+    errorMessage?: string;
+    required?: boolean;
+    invalid?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    columns?: 'auto' | '2' | '3';
+    density?: 'default' | 'compact';
+    selectionIndicator?: 'mark' | 'none';
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends SelectionKey = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<Props<T> & {
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        /** Дополнительное описание группы. / Supporting group description. */
+        help?: () => VNodeChild;
+        /** Сообщение ошибки при invalid=true. / Error message when invalid=true. */
+        error?: () => VNodeChild;
+    };
+    emit: (evt: "update:modelValue", value: T) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

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