@pgcorp/ui-kit 0.10.0 → 0.10.1

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

@@ -0,0 +1,241 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { useInteractiveLeafRegistration as t } from "../../../internal/passiveContentContract.js";
+import { useMenuLayer as n } from "../../../internal/useMenuLayer.js";
+import r from "../_internal/SMenuLayer.vue.js";
+import { menuContextKey as i, menuDepthKey as a } from "../_internal/menuContext.js";
+import ee from "../_internal/SMenuItem.vue.js";
+import o from "../_internal/SMenuSeparator.vue.js";
+import { validateSMenuEntries as s } from "./menu.js";
+import { Fragment as c, Teleport as l, computed as u, createBlock as d, createCommentVNode as f, createElementBlock as p, createVNode as m, defineComponent as h, inject as g, mergeProps as _, nextTick as v, onBeforeUnmount as y, onMounted as b, openBlock as x, provide as S, ref as C, renderList as te, resolveComponent as ne, toRef as re, unref as w, watch as ie, withCtx as T } from "vue";
+//#region src/components/shared/controls/SMenuSurface.vue?vue&type=script&setup=true&lang.ts
+var E = [
+	"data-density",
+	"data-orientation",
+	"aria-label",
+	"aria-orientation"
+], D = /*@__PURE__*/ h({
+	inheritAttrs: !1,
+	__name: "SMenuSurface",
+	props: {
+		label: {},
+		items: {},
+		density: { default: "comfortable" },
+		orientation: { default: "vertical" },
+		autofocus: {
+			type: Boolean,
+			default: !1
+		},
+		initialFocus: { default: "first" }
+	},
+	emits: [
+		"escape",
+		"focus-exit",
+		"select",
+		"tab",
+		"submenu-back",
+		"dismiss-tree"
+	],
+	setup(h, { expose: D, emit: O }) {
+		let k = h, A = O, j = e({
+			component: "SMenuSurface",
+			owner: "menu root"
+		});
+		t({ owner: "SMenuSurface" });
+		let M = g(a, -1) + 1;
+		S(a, M);
+		let N = C(null), P = /* @__PURE__ */ new Map();
+		S(i, {
+			density: re(k, "density"),
+			register: (e) => {
+				if (P.has(e.entryId)) throw Error(`SMenuSurface: duplicate mounted entry id '${e.entryId}'`);
+				return P.set(e.entryId, e), () => P.delete(e.entryId);
+			}
+		});
+		let F = C(null), I = C(!0), L = C(null), R = C(null), z = u(() => L.value?.getElement() ?? null), { position: B, zIndex: V, open: H, close: U } = n(z, { onDismiss: (e) => {
+			F.value = null, e === "outside" && A("dismiss-tree");
+		} }), W = u(() => {
+			let e = k.items.find((e) => e.id === F.value);
+			return e?.kind === "submenu" ? e : null;
+		}), G = "", K = null, q = () => [...P.values()].filter((e) => e.element().isConnected).sort((e, t) => {
+			let n = e.element().compareDocumentPosition(t.element());
+			return n & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : n & Node.DOCUMENT_POSITION_PRECEDING ? 1 : 0;
+		}), J = (e, t) => {
+			for (let t of e) t.setTabStop(!1);
+			let n = e[t];
+			n && (n.setTabStop(!0), n.focus());
+		}, Y = () => {
+			let e = q();
+			e.length > 0 && J(e, 0);
+		}, X = () => {
+			let e = q();
+			e.length > 0 && J(e, e.length - 1);
+		}, ae = () => {
+			if (typeof k.label != "string" || !k.label.trim()) throw TypeError("SMenuSurface: label must be a non-empty string");
+			s(k.items);
+		}, oe = (e) => {
+			let t = q();
+			if (t.length === 0) return;
+			let n = t.findIndex((e) => e.isFocused());
+			J(t, ((n < 0 ? e === 1 ? -1 : 0 : n) + e + t.length) % t.length);
+		}, se = (e) => {
+			let t = e.toLocaleLowerCase();
+			G += t, K && clearTimeout(K), K = setTimeout(() => {
+				G = "", K = null;
+			}, 500);
+			let n = [...G].every((e) => e === t) ? t : G, r = q();
+			if (r.length === 0) return;
+			let i = r.findIndex((e) => e.isFocused()), a = [...r.slice(i + 1), ...r.slice(0, i + 1)].find((e) => e.label().trim().toLocaleLowerCase().startsWith(n));
+			a && J(r, r.indexOf(a));
+		};
+		async function Z(e, t) {
+			let n = k.items.find((t) => t.id === e), r = P.get(e);
+			if (n?.kind === "submenu" && !n.disabled && r) {
+				if (F.value === e) {
+					t && await v(() => R.value?.focusFirst());
+					return;
+				}
+				F.value && U("outside"), I.value = t, F.value = e, await H({
+					type: "element",
+					element: r.element(),
+					align: "left",
+					placement: "inline"
+				}, r.element()), t && await v(() => R.value?.focusFirst());
+			}
+		}
+		function Q(e) {
+			F.value &&= (U(e), null);
+		}
+		function ce(e) {
+			e.kind === "submenu" && !e.disabled ? Z(e.id, !1) : F.value && Q("outside");
+		}
+		function le(e, t) {
+			e.kind === "submenu" || e.disabled || A("select", e, t);
+		}
+		function ue(e, t) {
+			A("select", e, t);
+		}
+		function $() {
+			return q().find((e) => e.isFocused());
+		}
+		let de = (e) => {
+			let t = e.target;
+			if (e.currentTarget !== t && !q().some((e) => e.ownsEventTarget(t))) return;
+			if (e.key === "Tab") {
+				A("tab", e);
+				return;
+			}
+			if (e.key === "Escape") {
+				e.preventDefault(), A("escape");
+				return;
+			}
+			let n = k.orientation === "horizontal" ? "ArrowRight" : "ArrowDown", r = k.orientation === "horizontal" ? "ArrowLeft" : "ArrowUp";
+			if (k.orientation === "vertical" && (e.key === "ArrowRight" || e.key === "ArrowLeft")) {
+				let t = $();
+				e.preventDefault(), e.key === "ArrowRight" && t?.hasSubmenu() ? Z(t.entryId, !0) : e.key === "ArrowLeft" && M > 0 && A("submenu-back");
+				return;
+			}
+			if (e.key === n || e.key === r) {
+				e.preventDefault(), oe(e.key === n ? 1 : -1);
+				return;
+			}
+			if (k.orientation === "horizontal" && e.key === "ArrowDown") {
+				let t = $();
+				t?.hasSubmenu() && (e.preventDefault(), Z(t.entryId, !0));
+				return;
+			}
+			if (e.key === "Home" || e.key === "End") {
+				e.preventDefault(), e.key === "Home" ? Y() : X();
+				return;
+			}
+			if (e.key === "Enter" || e.key === " ") {
+				let t = $();
+				t && t.activate(e);
+				return;
+			}
+			e.key.length === 1 && !e.altKey && !e.ctrlKey && !e.metaKey && se(e.key);
+		}, fe = (e) => {
+			let t = e.relatedTarget;
+			t instanceof Node && (N.value?.contains(t) || z.value?.contains(t)) || A("focus-exit", e);
+		};
+		return b(() => {
+			k.autofocus && v(k.initialFocus === "last" ? X : Y);
+		}), ie(() => [k.label, k.items], () => {
+			ae(), F.value && !W.value && Q("outside");
+		}, {
+			immediate: !0,
+			deep: !0
+		}), y(() => {
+			K && clearTimeout(K);
+		}), D({
+			focusFirst: Y,
+			focusLast: X
+		}), (e, t) => {
+			let n = ne("SMenuSurface", !0);
+			return x(), p("div", _({
+				ref_key: "surfaceRef",
+				ref: N
+			}, w(j).bindings(), {
+				class: "s-menu-surface",
+				"data-density": h.density,
+				"data-orientation": h.orientation,
+				"data-menu-depth": M,
+				role: "menu",
+				"aria-label": h.label,
+				"aria-orientation": h.orientation,
+				onKeydown: de,
+				onFocusout: fe
+			}), [(x(!0), p(c, null, te(h.items, (e) => (x(), p(c, { key: e.id }, [e.kind === "separator" ? (x(), d(o, {
+				key: 0,
+				"entry-id": e.id
+			}, null, 8, ["entry-id"])) : (x(), d(ee, {
+				key: 1,
+				entry: e,
+				"submenu-open": W.value?.id === e.id,
+				onSelect: (t) => le(e, t),
+				onOpenSubmenu: (t) => Z(e.id, !0),
+				onPointerIntent: (t) => ce(e)
+			}, null, 8, [
+				"entry",
+				"submenu-open",
+				"onSelect",
+				"onOpenSubmenu",
+				"onPointerIntent"
+			]))], 64))), 128)), (x(), d(l, { to: "body" }, [W.value ? (x(), d(r, {
+				key: 0,
+				ref_key: "submenuLayerRef",
+				ref: L,
+				kind: "submenu",
+				"landmark-label": `${h.label}: ${W.value.label}`,
+				position: w(B),
+				"z-index": w(V)
+			}, {
+				default: T(() => [m(n, {
+					ref_key: "submenuSurfaceRef",
+					ref: R,
+					label: `${h.label}: ${W.value.label}`,
+					items: W.value.children,
+					density: h.density,
+					orientation: "vertical",
+					autofocus: I.value,
+					onEscape: t[0] ||= (e) => Q("escape"),
+					onSubmenuBack: t[1] ||= (e) => Q("escape"),
+					onDismissTree: t[2] ||= (e) => A("dismiss-tree"),
+					onSelect: ue,
+					onTab: t[3] ||= (e) => A("tab", e)
+				}, null, 8, [
+					"label",
+					"items",
+					"density",
+					"autofocus"
+				])]),
+				_: 1
+			}, 8, [
+				"landmark-label",
+				"position",
+				"z-index"
+			])) : f("", !0)]))], 16, E);
+		};
+	}
+});
+//#endregion
+export { D as default };

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

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

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

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

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

@@ -0,0 +1,128 @@
+import { mergeIdReferences as e, useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { resolveOptionalDomId as n } from "../../../internal/runtimeContract.js";
+import { useInteractiveLeafRegistration as r } from "../../../internal/passiveContentContract.js";
+import i from "./SField.vue.js";
+import { computed as a, createBlock as o, createCommentVNode as s, createElementBlock as c, createElementVNode as l, defineComponent as u, mergeProps as d, openBlock as f, toDisplayString as p, unref as m, useId as h, withCtx as g } from "vue";
+//#region src/components/shared/controls/SRange.vue?vue&type=script&setup=true&lang.ts
+var _ = { class: "s-range" }, v = [
+	"id",
+	"min",
+	"max",
+	"step",
+	"value",
+	"disabled",
+	"aria-invalid",
+	"aria-readonly",
+	"aria-required",
+	"aria-describedby"
+], y = ["for"], b = /*@__PURE__*/ u({
+	inheritAttrs: !1,
+	__name: "SRange",
+	props: {
+		modelValue: {},
+		min: {},
+		max: {},
+		step: { default: 1 },
+		label: {},
+		id: { 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 },
+		showValue: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(u, { emit: b }) {
+		let x = u, S = b;
+		function C(e, t) {
+			if (!Number.isFinite(t)) throw TypeError(`SRange: ${e} должен быть конечным числом / must be a finite number`);
+			return t;
+		}
+		let w = a(() => C("min", x.min)), T = a(() => {
+			let e = C("max", x.max);
+			if (e <= w.value) throw RangeError("SRange: max должен быть больше min / max must be greater than min");
+			return e;
+		}), E = a(() => {
+			let e = C("step", x.step);
+			if (e <= 0) throw RangeError("SRange: step должен быть больше нуля / step must be greater than zero");
+			return e;
+		}), D = a(() => {
+			let e = C("modelValue", x.modelValue);
+			if (e < w.value || e > T.value) throw RangeError("SRange: modelValue должен находиться внутри [min, max] / must be within [min, max]");
+			return e;
+		}), O = h(), k = a(() => n("SRange", "id", x.id, `s-range-${O}`)), A = t({
+			component: "SRange",
+			owner: "native range input"
+		});
+		r({ owner: "SRange" });
+		function j(e) {
+			let t = e.currentTarget;
+			if (!(t instanceof HTMLInputElement)) throw TypeError("SRange: input event owner must be the native range input");
+			if (x.readonly) {
+				t.value = String(D.value);
+				return;
+			}
+			let n = Number(t.value);
+			C("input value", n), S("update:modelValue", n);
+		}
+		return (t, n) => (f(), o(i, {
+			"control-id": k.value,
+			label: u.label,
+			disabled: u.disabled,
+			readonly: u.readonly,
+			required: u.required,
+			"help-text": u.helpText,
+			"error-message": u.errorMessage,
+			invalid: u.invalid
+		}, {
+			default: g((t) => [l("div", _, [l("input", d(m(A).bindings(), {
+				id: t.controlId,
+				class: "s-range__input",
+				type: "range",
+				min: w.value,
+				max: T.value,
+				step: E.value,
+				value: D.value,
+				disabled: t.disabled,
+				"aria-invalid": t.invalid || void 0,
+				"aria-readonly": t.readonly || void 0,
+				"aria-required": t.required || void 0,
+				"aria-describedby": m(e)(m(A).string("aria-describedby"), t.describedBy),
+				onInput: j
+			}), null, 16, v), u.showValue ? (f(), c("output", {
+				key: 0,
+				class: "s-range__value",
+				for: t.controlId
+			}, p(D.value), 9, y)) : s("", !0)])]),
+			_: 1
+		}, 8, [
+			"control-id",
+			"label",
+			"disabled",
+			"readonly",
+			"required",
+			"help-text",
+			"error-message",
+			"invalid"
+		]));
+	}
+});
+//#endregion
+export { b as default };

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

@@ -0,0 +1,43 @@
+import { SelectionKey, SelectionKey as PublicSelectionKey } from '../_internal/useSelectionRoving';
+/** Одна option сегментированного выбора. / One segmented selection option. */
+export type SegmentedControlOption<T extends PublicSelectionKey = string> = {
+    value: T;
+    label: string;
+    title?: string;
+    disabled?: boolean;
+};
+/** Публичный field/radiogroup-контракт сегментированного выбора. / Public segmented field/radiogroup contract. */
+export interface Props<T extends PublicSelectionKey = string> {
+    modelValue: T;
+    options: readonly SegmentedControlOption<T>[];
+    label: string;
+    id?: string;
+    helpText?: string;
+    errorMessage?: string;
+    required?: boolean;
+    invalid?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    size?: 'sm' | 'md';
+    optionWrap?: 'wrap' | 'nowrap';
+}
+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: {};
+    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/SSegmentedControl.vue.js

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

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

@@ -0,0 +1,99 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { useInteractiveLeafRegistration as t } from "../../../internal/passiveContentContract.js";
+import n from "./SFieldGroup.vue.js";
+import { useRadioGroup as r } from "../_internal/useRadioGroup.js";
+import { Fragment as i, computed as a, createBlock as o, createElementBlock as s, createElementVNode as c, defineComponent as l, mergeProps as u, openBlock as d, renderList as f, toDisplayString as p, unref as m, withCtx as h } from "vue";
+//#region src/components/shared/controls/SSegmentedControl.vue?vue&type=script&setup=true&lang.ts
+var g = [
+	"data-size",
+	"data-option-wrap",
+	"data-invalid",
+	"data-readonly"
+], _ = ["data-size", "title"], v = /*@__PURE__*/ l({
+	inheritAttrs: !1,
+	__name: "SSegmentedControl",
+	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
+		},
+		size: { default: "md" },
+		optionWrap: { default: "wrap" }
+	},
+	emits: ["update:modelValue"],
+	setup(l, { emit: v }) {
+		let y = l, b = v, x = e({
+			component: "SSegmentedControl",
+			owner: "field group root"
+		});
+		t({ owner: "SSegmentedControl" });
+		let S = r({
+			options: a(() => y.options),
+			selectedValue: a(() => y.modelValue),
+			disabled: a(() => y.disabled),
+			readonly: a(() => y.readonly),
+			update: (e) => b("update:modelValue", e),
+			component: "SSegmentedControl"
+		});
+		return (e, t) => (d(), o(n, u(m(x).bindings(), {
+			id: l.id,
+			label: l.label,
+			"help-text": l.helpText,
+			"error-message": l.errorMessage,
+			required: l.required,
+			invalid: l.invalid,
+			disabled: l.disabled,
+			readonly: l.readonly
+		}), {
+			default: h((e) => [c("div", u({
+				class: "s-segmented-control__group",
+				"data-size": l.size,
+				"data-option-wrap": l.optionWrap,
+				"data-invalid": e.invalid || void 0,
+				"data-readonly": e.readonly || void 0
+			}, m(S).groupBindings({
+				labelledBy: e.labelId,
+				describedBy: e.describedBy,
+				required: e.required,
+				invalid: e.invalid
+			})), [(d(!0), s(i, null, f(l.options, (e) => (d(), s("button", u({
+				key: m(S).optionToken(e.value),
+				ref_for: !0,
+				ref: m(S).optionRef(e.value),
+				class: "s-segmented-control__item",
+				"data-size": l.size,
+				title: e.title
+			}, { ref_for: !0 }, m(S).optionBindings(e)), p(e.label), 17, _))), 128))], 16, g)]),
+			_: 1
+		}, 16, [
+			"id",
+			"label",
+			"help-text",
+			"error-message",
+			"required",
+			"invalid",
+			"disabled",
+			"readonly"
+		]));
+	}
+});
+//#endregion
+export { v as default };

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

@@ -0,0 +1,64 @@
+import { SelectionKey, SelectionKey as PublicSelectionKey } from '../_internal/useSelectionRoving';
+import { SelectionEntry as PublicSelectionEntry, SelectionMode as PublicSelectionMode, SelectionModelValue as PublicSelectionModelValue, SelectionOption as PublicSelectionOption, SelectionOptionGroup as PublicSelectionOptionGroup } from '../_internal/selectionContract';
+import { SMarker as PublicMarker } from '../_internal/markerContract';
+export type SSelectOption<TKey extends PublicSelectionKey = PublicSelectionKey> = PublicSelectionOption<TKey>;
+export type SSelectOptionGroup<TKey extends PublicSelectionKey = PublicSelectionKey> = PublicSelectionOptionGroup<TKey>;
+export type SSelectEntry<TKey extends PublicSelectionKey = PublicSelectionKey> = PublicSelectionEntry<TKey>;
+export type SSelectMode = PublicSelectionMode;
+export type SSelectModelValue<TKey extends PublicSelectionKey, TMode extends SSelectMode> = PublicSelectionModelValue<TKey, TMode>;
+interface SharedProps<TKey extends PublicSelectionKey> {
+    options: readonly SSelectEntry<TKey>[];
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    errorMessage?: string;
+    helpText?: string;
+    emptyOptionLabel?: string;
+    id?: string;
+    size?: 'xs' | 'sm' | 'md';
+    appearance?: 'field' | 'swatch';
+    align?: 'left' | 'right' | 'center';
+    triggerMarker?: PublicMarker;
+    title?: string;
+}
+export type Props<TKey extends PublicSelectionKey = PublicSelectionKey, TMode extends SSelectMode = 'single'> = SharedProps<TKey> & (TMode extends 'multiple' ? {
+    selectionMode: 'multiple';
+    modelValue: readonly TKey[];
+    emptyOptionLabel?: never;
+} : {
+    selectionMode?: 'single';
+    modelValue: TKey | null;
+    emptyOptionLabel?: string;
+});
+type ComponentProps<TKey extends PublicSelectionKey> = SharedProps<TKey> & ({
+    selectionMode?: 'single';
+    modelValue: TKey | null;
+    emptyOptionLabel?: string;
+} | {
+    selectionMode: 'multiple';
+    modelValue: readonly TKey[];
+    emptyOptionLabel?: never;
+});
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <TKey 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<ComponentProps<TKey> & {
+        [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", ...args: [value: TKey | null] | [value: readonly TKey[]]) => 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/SSelect.vue.js

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