@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/containers/SSidebarSection.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,181 @@
+import { useDisclosure as e } from "../../../composables/useDisclosure.js";
+import { useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import n from "../controls/SButton.vue.js";
+import r from "../../layout/SResizeHandle.vue.js";
+import i from "../_internal/SDisclosureSummary.vue.js";
+import { sidebarGroupContextKey as a } from "../_internal/sidebarGroupContext.js";
+import { computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, createVNode as d, defineComponent as f, inject as p, mergeProps as m, normalizeClass as h, onBeforeUnmount as g, onMounted as _, openBlock as v, ref as y, renderSlot as b, unref as x, useId as S, useSlots as C, watch as w, withCtx as T } from "vue";
+//#region src/components/shared/containers/SSidebarSection.vue?vue&type=script&setup=true&lang.ts
+var E = { class: "s-sidebar-section" }, D = { class: "s-sidebar-section-trigger" }, O = {
+	key: 0,
+	class: "s-sidebar-section-actions"
+}, k = ["id", "aria-labelledby"], A = /*@__PURE__*/ f({
+	name: "SSidebarSection",
+	inheritAttrs: !1,
+	__name: "SSidebarSection",
+	props: {
+		summary: {},
+		summaryTypography: { default: "strong" },
+		summaryCase: { default: "uppercase" },
+		summaryState: { default: void 0 },
+		summaryFacts: { default: () => [] },
+		summaryBadges: { default: () => [] },
+		summaryStatus: { default: void 0 },
+		stateKey: {},
+		layout: { default: "desktop" },
+		disabled: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	setup(f) {
+		let A = f, j = C(), M = y(null), N = t({
+			component: "SSidebarSection",
+			owner: "sidebar section wrapper"
+		}), P = o(() => !!j.actions), F = p(a);
+		if (!F) throw Error("SSidebarSection: component must be rendered inside SSidebarGroup");
+		let I = F;
+		if (A.stateKey.trim().length === 0) throw TypeError("SSidebarSection: stateKey must be a non-empty string");
+		let L = A.stateKey, R = `s-sidebar-section-${S()}-${A.stateKey.replace(/[^a-zA-Z0-9_-]/g, "-")}`, z = null, B = y(!1);
+		_(() => {
+			let e = M.value;
+			if (!e) throw Error("SSidebarSection: section wrapper is unavailable during mount");
+			z = I.registerSection({
+				key: L,
+				element: e
+			}), B.value = !0;
+		}), g(() => {
+			B.value = !1, z?.(), z = null;
+		}), w(() => A.stateKey, (e) => {
+			if (e !== L) throw Error(`SSidebarSection: stateKey is immutable after setup; received '${L}' -> '${e}'`);
+		});
+		let V = o(() => {
+			let e = I.orderedSections.value.findIndex((e) => e.key === L);
+			if (B.value && e < 0) throw Error(`SSidebarSection: registered section '${L}' is absent from group order`);
+			return e;
+		}), H = o(() => {
+			let e = I.sectionsState.value[L];
+			if (!e) throw Error(`SSidebarSection: sectionsState has no entry for stateKey '${L}'`);
+			return e.isOpen;
+		}), U = e({
+			id: R,
+			open: H,
+			disabled: () => A.disabled ?? !1,
+			onUpdate: () => I.toggleSection(L)
+		}), { triggerId: W, panelId: G } = U, K = o(() => I.getSectionStyle(L)), q = o(() => {
+			if (V.value <= 0 || !H.value) return !1;
+			let e = I.orderedSections.value;
+			for (let t = V.value - 1; t >= 0; t--) if (e[t]?.state.isOpen) return !0;
+			return !1;
+		}), J = o(() => {
+			for (let e = V.value - 1; e >= 0; e--) if (I.orderedSections.value[e]?.state.isOpen) return e;
+			return -1;
+		});
+		function Y(e) {
+			return Math.max(e.state.minSize, I.getSectionSize(e.key));
+		}
+		function X() {
+			if (J.value < 0 || V.value < 0) throw Error(`SSidebarSection: resize pair is unavailable for section '${L}'`);
+			let e = I.orderedSections.value, t = e[J.value], n = e[V.value];
+			if (!t || !n) throw Error(`SSidebarSection: resize pair indices are outside mounted group order for section '${L}'`);
+			return [t, n];
+		}
+		let Z = o(() => {
+			I.geometryRevision.value;
+			let [e, t] = X(), n = I.orderedSections.value.filter((e) => e.state.isOpen), r = n.findIndex((t) => t.key === e.key), i = n.slice(0, r + 1), a = n.slice(r + 1), o = i.reduce((e, t) => e + Y(t), 0), s = i.reduce((e, t) => e + t.state.minSize, 0), c = a.reduce((e, t) => e + t.state.minSize, 0), l = o + a.reduce((e, t) => e + Y(t), 0);
+			return {
+				value: o,
+				min: s,
+				max: Math.max(s, l - c),
+				testId: `sidebar-resize-${e.key}-${t.key}`
+			};
+		});
+		function Q() {
+			let [e, t] = X();
+			I.beginResize(e.key, t.key);
+		}
+		function $(e) {
+			let [t, n] = X();
+			I.resizeSections(t.key, n.key, e);
+		}
+		function ee() {
+			let [e, t] = X();
+			I.finishResize(e.key, t.key);
+		}
+		return (e, t) => (v(), l("div", m(x(N).bindings(), {
+			ref_key: "sectionEl",
+			ref: M,
+			class: ["s-sidebar-section-wrapper", { "s-sidebar-section-wrapper--resizable-before": q.value }],
+			style: K.value
+		}), [q.value ? (v(), s(r, {
+			key: 0,
+			orientation: "horizontal",
+			label: "Изменить высоту секций",
+			value: Z.value.value,
+			min: Z.value.min,
+			max: Z.value.max,
+			step: 10,
+			"data-test-id": Z.value.testId,
+			onResizeStart: Q,
+			onResize: $,
+			onResizeEnd: ee
+		}, null, 8, [
+			"value",
+			"min",
+			"max",
+			"data-test-id"
+		])) : c("", !0), u("div", E, [u("div", { class: h(["s-sidebar-section-header", { "s-sidebar-section-header--mobile": f.layout === "mobile" }]) }, [u("div", D, [d(n, {
+			id: x(W),
+			size: f.layout === "mobile" ? "xs" : "sm",
+			spacing: "tight",
+			"hover-surface": "parent",
+			severity: "secondary",
+			appearance: "ghost",
+			shape: "row",
+			width: "full",
+			"content-align": "start",
+			"data-sidebar-section-toggle": "",
+			disabled: f.disabled,
+			disclosure: {
+				expanded: H.value,
+				controls: x(G),
+				iconPlacement: "leading"
+			},
+			onClick: x(U).toggle
+		}, {
+			default: T(() => [d(i, {
+				title: f.summary,
+				typography: f.summaryTypography,
+				casing: f.summaryCase,
+				state: f.summaryState,
+				facts: f.summaryFacts,
+				badges: f.summaryBadges,
+				status: f.summaryStatus
+			}, null, 8, [
+				"title",
+				"typography",
+				"casing",
+				"state",
+				"facts",
+				"badges",
+				"status"
+			])]),
+			_: 1
+		}, 8, [
+			"id",
+			"size",
+			"disabled",
+			"disclosure",
+			"onClick"
+		])]), P.value ? (v(), l("div", O, [b(e.$slots, "actions", {}, void 0, !0)])) : c("", !0)], 2), H.value ? (v(), l("div", {
+			key: 0,
+			id: x(G),
+			"aria-labelledby": x(W),
+			role: "region",
+			tabindex: "0",
+			class: "s-sidebar-section-content"
+		}, [b(e.$slots, "default", {}, void 0, !0)], 8, k)) : c("", !0)])], 16));
+	}
+});
+//#endregion
+export { A as default };

package/dist/src/components/shared/containers/SUiKitLocaleProvider.vue.d.ts

@@ -0,0 +1,19 @@
+import { UiKitLocale, UiKitMessagesOverride } from '../../../locales/locale';
+type __VLS_Props = {
+    /** Locale for this subtree; omission inherits the nearest provider and ultimately defaults to ru. */
+    locale?: UiKitLocale;
+    /** Exact deep partial override for this subtree. Unknown fields fail at runtime. */
+    messages?: UiKitMessagesOverride;
+};
+type __VLS_Slots = {
+    default: () => unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, 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/containers/SUiKitLocaleProvider.vue.js

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

package/dist/src/components/shared/containers/SUiKitLocaleProvider.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,36 @@
+import { UI_KIT_MESSAGES as e, createUiKitTranslate as t, mergeUiKitMessages as n } from "../../../locales/messages.js";
+import { UI_KIT_LOCALE_CONTEXT as r, resolveUiKitLocaleContext as i } from "../../../internal/localeContext.js";
+import { UI_KIT_LOCALES as a } from "../../../locales/locale.js";
+import { useOwnedAttrs as o } from "../../../internal/ownedAttrs.js";
+import { computed as s, createCommentVNode as c, defineComponent as l, provide as u, renderSlot as d } from "vue";
+//#region src/components/shared/containers/SUiKitLocaleProvider.vue?vue&type=script&setup=true&lang.ts
+var f = /*@__PURE__*/ l({
+	inheritAttrs: !1,
+	__name: "SUiKitLocaleProvider",
+	props: {
+		locale: {},
+		messages: {}
+	},
+	setup(l) {
+		let f = l, p = i(), m = o({
+			component: "SUiKitLocaleProvider",
+			owner: "DOM-less locale boundary"
+		}), h = s(() => {
+			let e = f.locale ?? p.locale.value;
+			if (!a.includes(e)) throw TypeError(`SUiKitLocaleProvider: неизвестная locale ${JSON.stringify(e)}.`);
+			return e;
+		}), g = s(() => {
+			let t = f.locale === void 0 || f.locale === p.locale.value ? p.messages.value : e[h.value];
+			return n(t, f.messages);
+		}), _ = Object.freeze({
+			locale: h,
+			messages: g,
+			t: t(() => g.value)
+		});
+		u(r, _);
+		let v = s(() => (m.reject("locale provider не создаёт DOM owner / locale provider does not render a DOM owner"), !0));
+		return (e, t) => v.value ? d(e.$slots, "default", {}, void 0, void 0, 0) : c("", !0);
+	}
+});
+//#endregion
+export { f as default };

package/dist/src/components/shared/containers/disclosureSummary.d.ts

@@ -0,0 +1,41 @@
+import { BadgeSeverity } from '../data-display/SBadge.vue';
+import { StatusTone } from '../data-display/SStatus.vue';
+/** Типографика заголовка disclosure. / Disclosure summary typography. */
+export type SDisclosureSummaryTypography = 'default' | 'strong' | 'mono';
+/** Регистр заголовка disclosure. / Disclosure summary letter case. */
+export type SDisclosureSummaryCase = 'sentence' | 'uppercase';
+/** Семантическое состояние с системной иконкой. / Semantic state with a system-owned icon. */
+export type SDisclosureSummaryState = 'neutral' | 'progress' | 'success' | 'warn' | 'danger';
+/** Семантический тон факта. / Semantic fact tone. */
+export type SDisclosureSummaryTone = 'neutral' | 'info' | 'success' | 'warn' | 'danger';
+/** Короткая пара label/value в заголовке. / Compact label/value pair in a summary. */
+export interface SDisclosureSummaryFact {
+    /** Стабильная identity факта, не зависящая от отображаемого значения. / Stable fact identity independent of its displayed value. */
+    id: string;
+    /** Необязательная подпись значения. / Optional value label. */
+    label?: string;
+    /** Отображаемое непустое значение. / Non-empty displayed value. */
+    value: string | number;
+    /** Семантический тон факта. / Semantic tone of the fact. */
+    tone?: SDisclosureSummaryTone;
+}
+/** Неинтерактивный badge в заголовке. / Non-interactive summary badge. */
+export interface SDisclosureSummaryBadge {
+    /** Стабильная identity badge, не зависящая от отображаемой подписи. / Stable badge identity independent of its displayed label. */
+    id: string;
+    /** Непустая подпись badge. / Non-empty badge label. */
+    label: string | number;
+    /** Семантическая важность badge. / Semantic badge severity. */
+    severity?: BadgeSeverity;
+    /** Дополнительная нативная подсказка. / Additional native tooltip. */
+    title?: string;
+}
+/** Текстовый статус в конце заголовка. / Trailing text status in a summary. */
+export interface SDisclosureSummaryStatus {
+    /** Непустая подпись статуса. / Non-empty status label. */
+    label: string;
+    /** Семантический тон статуса. / Semantic status tone. */
+    tone?: StatusTone;
+    /** Дополнительная нативная подсказка. / Additional native tooltip. */
+    title?: string;
+}

package/{src/components/shared/containers/popover.ts → dist/src/components/shared/containers/popover.d.ts}

@@ -1,72 +1,61 @@
-import type { InteractiveElementRefTarget } from '../../../internal/interactiveElement'
-import type { SButtonDisclosure } from '../controls/SButton.vue'
-
+import { InteractiveElementRefTarget } from '../../../internal/interactiveElement';
+import { SButtonDisclosure } from '../controls/SButton.vue';
 /**
  * Режим реакции custom trigger на единый click-контракт.
  * Custom-trigger activation mode for the unified click contract.
  */
-export type SPopoverTriggerActivation = 'toggle' | 'manual'
-
+export type SPopoverTriggerActivation = 'toggle' | 'manual';
 /**
  * Допустимая цель callback-ref custom trigger.
  * Supported callback-ref target for a custom trigger.
  */
-export type SPopoverTriggerRefTarget = InteractiveElementRefTarget
-
+export type SPopoverTriggerRefTarget = InteractiveElementRefTarget;
 /**
  * Полный контракт для `v-bind` непосредственно на button-root custom trigger.
  * Complete contract for `v-bind` directly on the custom trigger button root.
  */
 export interface SPopoverTriggerBinding {
-  readonly ref: (target: SPopoverTriggerRefTarget) => void
-  readonly disclosure: SButtonDisclosure
-  readonly 'aria-expanded': boolean
-  readonly 'aria-haspopup': 'dialog'
-  readonly 'aria-controls': string
-  readonly onClick: (event: MouseEvent) => void
+    readonly ref: (target: SPopoverTriggerRefTarget) => void;
+    readonly disclosure: SButtonDisclosure;
+    readonly 'aria-expanded': boolean;
+    readonly 'aria-haspopup': 'dialog';
+    readonly 'aria-controls': string;
+    readonly onClick: (event: MouseEvent) => void;
 }
-
 /**
  * Binder создаёт один контракт для каждого уникального trigger id.
  * The binder creates one contract for every unique trigger id.
  */
-export type SPopoverTriggerBinder = (
-  triggerId: string,
-  activation?: SPopoverTriggerActivation,
-) => SPopoverTriggerBinding
-
+export type SPopoverTriggerBinder = (triggerId: string, activation?: SPopoverTriggerActivation) => SPopoverTriggerBinding;
 /**
  * Публичный scoped-контракт custom trigger.
  * Public scoped contract for custom triggers.
  */
 export interface SPopoverTriggerSlotProps {
-  readonly bindTrigger: SPopoverTriggerBinder
-  readonly open: (triggerId?: string) => void
-  readonly close: () => void
-  readonly isOpen: boolean
+    readonly bindTrigger: SPopoverTriggerBinder;
+    readonly open: (triggerId?: string) => void;
+    readonly close: () => void;
+    readonly isOpen: boolean;
 }
-
 /**
  * Содержимое built-in trigger получает только наблюдаемое состояние.
  * Built-in trigger content receives observable state only.
  */
 export interface SPopoverDefaultSlotProps {
-  readonly isOpen: boolean
+    readonly isOpen: boolean;
 }
-
 /**
  * Панель может запросить явное закрытие с возвратом focus к trigger.
  * The panel may explicitly close and restore focus to its trigger.
  */
 export interface SPopoverPanelSlotProps {
-  readonly close: () => void
+    readonly close: () => void;
 }
-
 /**
  * Публичный programmatic API использует зарегистрированный anchor.
  * The public programmatic API uses a registered anchor.
  */
 export interface SPopoverPublicApi {
-  open: (triggerId?: string) => void
-  close: () => void
+    open: (triggerId?: string) => void;
+    close: () => void;
 }

package/dist/src/components/shared/containers/sidebar.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Состояние размера и раскрытия одной sidebar-секции.
+ * Size and disclosure state of one sidebar section.
+ */
+export interface SectionState {
+    readonly isOpen: boolean;
+    readonly size: number | null;
+    readonly minSize: number;
+}
+/**
+ * Точная controlled-state карта под управлением consumer.
+ * Exact controlled state map owned by the consumer.
+ */
+export type SidebarSectionsState = Readonly<Record<string, Readonly<SectionState>>>;
+/** Exact payload map общего владельца sidebar-секций. / Exact payload map of the shared sidebar-section owner. */
+export interface SidebarGroupEmits {
+    'update-sections': [state: SidebarSectionsState];
+    'toggle-section': [key: string];
+}
+/**
+ * Одна точная immutable-замена секции в controlled transition.
+ * One exact immutable section replacement in a controlled transition.
+ */
+export interface SidebarSectionReplacement {
+    readonly key: string;
+    readonly state: Readonly<SectionState>;
+}
+/**
+ * Проверяет полный точный controlled-контракт геометрии sidebar.
+ * Validates the complete exact controlled sidebar geometry contract.
+ */
+export declare function assertSidebarSectionsState(state: unknown, owner?: string): asserts state is SidebarSectionsState;
+/**
+ * Проверяет, копирует и глубоко замораживает полное controlled-state значение.
+ * Validates, copies, and deeply freezes one complete controlled state value.
+ */
+export declare function createSidebarSectionsState(state: unknown, owner?: string): SidebarSectionsState;
+/**
+ * Создаёт deeply immutable controlled transition без мутации или сериализации входа.
+ * Creates one deeply immutable controlled transition without mutating or serializing its input.
+ */
+export declare function createSidebarSectionsTransition(current: SidebarSectionsState, replacements: readonly SidebarSectionReplacement[]): SidebarSectionsState;
+/**
+ * Сравнивает точные public state fields без coercion.
+ * Compares the exact public state fields without coercion.
+ */
+export declare function sidebarSectionsStateEqual(left: SidebarSectionsState, right: SidebarSectionsState): boolean;

package/dist/src/components/shared/containers/sidebar.js

@@ -0,0 +1,65 @@
+import { hasOwn as e } from "../../../internal/es2020.js";
+//#region src/components/shared/containers/sidebar.ts
+var t = Object.freeze([
+	"isOpen",
+	"minSize",
+	"size"
+]);
+function n(e, t, n) {
+	if (typeof n != "object" || !n || Array.isArray(n)) throw TypeError(`${e}: ${t} must be a plain data record`);
+	let r = Object.getPrototypeOf(n);
+	if (r !== Object.prototype && r !== null) throw TypeError(`${e}: ${t} must be a plain data record`);
+	if (Object.getOwnPropertySymbols(n).length > 0) throw TypeError(`${e}: ${t} must not contain symbol properties`);
+	for (let [r, i] of Object.entries(Object.getOwnPropertyDescriptors(n))) if (!i.enumerable || !("value" in i)) throw TypeError(`${e}: ${t}.${r} must be an enumerable data property`);
+}
+function r(e, r, i) {
+	n(e, r, i);
+	let a = Object.keys(i).sort();
+	if (a.length !== t.length || a.some((e, n) => e !== t[n])) throw TypeError(`${e}: ${r} must contain exactly [${t.join(", ")}]`);
+	if (typeof i.isOpen != "boolean") throw TypeError(`${e}: ${r}.isOpen must be a boolean`);
+	if (typeof i.minSize != "number" || !Number.isFinite(i.minSize) || i.minSize < 0) throw TypeError(`${e}: ${r}.minSize must be a non-negative finite number`);
+	if (i.size !== null && (typeof i.size != "number" || !Number.isFinite(i.size) || i.size < i.minSize)) throw TypeError(`${e}: ${r}.size must be null or a finite number not below minSize`);
+}
+function i(e, t = "SSidebarGroup") {
+	n(t, "sectionsState", e);
+	let i = [];
+	for (let [n, a] of Object.entries(e)) {
+		if (n.trim().length === 0) throw TypeError(`${t}: section keys must be non-empty strings`);
+		r(t, `sectionsState.${n}`, a), a.isOpen && i.push(a);
+	}
+	let a = i.filter((e) => e.size === null).length;
+	if (i.length > 0 && a !== 1) throw TypeError(`${t}: exactly one open section must have size=null; received ${a}`);
+}
+function a(e) {
+	return Object.freeze({
+		isOpen: e.isOpen,
+		size: e.size,
+		minSize: e.minSize
+	});
+}
+function o(e, t = "SSidebarGroup") {
+	return i(e, t), Object.freeze(Object.fromEntries(Object.entries(e).map(([e, t]) => [e, a(t)])));
+}
+function s(t, s) {
+	if (i(t), !Array.isArray(s) || s.length === 0) throw TypeError("SSidebarGroup: a transition requires at least one section replacement");
+	let c = /* @__PURE__ */ new Map();
+	for (let [i, a] of s.entries()) {
+		n("SSidebarGroup", `replacements[${i}]`, a);
+		let o = Object.keys(a).sort();
+		if (o.length !== 2 || o[0] !== "key" || o[1] !== "state") throw TypeError(`SSidebarGroup: replacements[${i}] must contain exactly [key, state]`);
+		if (typeof a.key != "string" || a.key.trim().length === 0) throw TypeError(`SSidebarGroup: replacements[${i}].key must be a non-empty string`);
+		if (!e(t, a.key)) throw Error(`SSidebarGroup: cannot replace unknown section '${a.key}'`);
+		if (c.has(a.key)) throw Error(`SSidebarGroup: duplicate replacement for section '${a.key}'`);
+		r("SSidebarGroup", `replacements[${i}].state`, a.state), c.set(a.key, a.state);
+	}
+	return o(Object.fromEntries(Object.entries(t).map(([e, t]) => [e, a(c.get(e) ?? t)])));
+}
+function c(e, t) {
+	let n = Object.keys(e), r = Object.keys(t);
+	return n.length === r.length && n.every((n) => {
+		let r = e[n], i = t[n];
+		return r !== void 0 && i !== void 0 && r.isOpen === i.isOpen && r.size === i.size && r.minSize === i.minSize;
+	});
+}
+//#endregion
+export { i as assertSidebarSectionsState, o as createSidebarSectionsState, s as createSidebarSectionsTransition, c as sidebarSectionsStateEqual };

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

@@ -0,0 +1,102 @@
+import { Component, VNodeChild } from 'vue';
+import { InteractiveElementApi } from '../../../internal/interactiveElement';
+import { BadgeSeverity } from '../data-display/SBadge.vue';
+import { LinkBrowsingTarget, LinkRouterTarget } from './SLink';
+export type SButtonSeverity = 'primary' | 'secondary' | 'success' | 'info' | 'warn' | 'danger' | 'contrast';
+export type SButtonSize = 'xs' | 'sm' | 'md' | 'lg';
+export type SButtonIconSize = 'default' | 'large';
+export type SButtonDensity = 'default' | 'compact';
+export type SButtonSpacing = 'default' | 'tight';
+export type SButtonHoverSurface = 'self' | 'parent';
+export type SButtonWidth = 'auto' | 'fit' | 'full';
+export type SButtonContentAlign = 'center' | 'start' | 'end' | 'between';
+export type SButtonAppearance = 'solid' | 'soft' | 'outline' | 'ghost' | 'text';
+export type SButtonShape = 'default' | 'pill' | 'square' | 'circle' | 'row';
+export type SButtonNativeType = 'button' | 'reset' | 'submit';
+export interface SButtonDisclosure {
+    expanded: boolean;
+    controls: string;
+    iconPlacement?: 'leading' | 'trailing' | 'none';
+}
+/** Typed interactive owner API for action and navigation buttons. / Типизированная API-поверхность action/navigation button. */
+export type SButtonApi = InteractiveElementApi<HTMLButtonElement | HTMLAnchorElement>;
+interface SButtonPresentationProps {
+    label?: string;
+    severity?: SButtonSeverity;
+    size?: SButtonSize;
+    disabled?: boolean;
+    loading?: boolean;
+    loadingLabel?: string;
+    leadingIcon?: Component;
+    trailingIcon?: Component;
+    iconSize?: SButtonIconSize;
+    density?: SButtonDensity;
+    spacing?: SButtonSpacing;
+    hoverSurface?: SButtonHoverSurface;
+    badge?: string | number;
+    badgeSeverity?: BadgeSeverity;
+    shortcut?: string;
+    iconOnly?: boolean;
+    width?: SButtonWidth;
+    contentAlign?: SButtonContentAlign;
+    appearance?: SButtonAppearance;
+    shape?: SButtonShape;
+    pressed?: boolean | 'mixed';
+    busy?: boolean;
+    disclosure?: SButtonDisclosure;
+}
+export type SButtonActionProps = SButtonPresentationProps & {
+    href?: never;
+    to?: never;
+    target?: never;
+    rel?: never;
+    type?: SButtonNativeType;
+};
+interface SButtonNavigationOptions {
+    target?: LinkBrowsingTarget;
+    rel?: string;
+}
+export type SButtonNavigationProps = SButtonPresentationProps & SButtonNavigationOptions & ({
+    href: string;
+    to?: never;
+    type?: never;
+} | {
+    href?: never;
+    to: LinkRouterTarget;
+    type?: never;
+});
+/** Strict action/navigation XOR with a shared button presentation. */
+export type Props = SButtonActionProps | SButtonNavigationProps;
+type __VLS_Slots = {
+    /** Пассивное содержимое action/navigation button. / Passive action/navigation button content. */
+    default?: () => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<SButtonActionProps | (SButtonPresentationProps & SButtonNavigationOptions & {
+    href: string;
+    to?: never;
+    type?: never;
+}) | (SButtonPresentationProps & SButtonNavigationOptions & {
+    href?: never;
+    to: LinkRouterTarget;
+    type?: never;
+}), SButtonApi, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<SButtonActionProps | (SButtonPresentationProps & SButtonNavigationOptions & {
+    href: string;
+    to?: never;
+    type?: never;
+}) | (SButtonPresentationProps & SButtonNavigationOptions & {
+    href?: never;
+    to: LinkRouterTarget;
+    type?: never;
+})> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, 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/SButton.vue.js

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