@pgcorp/ui-kit 0.10.0 → 0.10.1

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

@@ -0,0 +1,30 @@
+import { SScrollViewportApi, SScrollViewportState, SScrollViewportAxis as PublicSScrollViewportAxis, SScrollViewportOverscrollBehavior as PublicSScrollViewportOverscrollBehavior } from './scrollViewport';
+import { ScrollViewportBlockSize as PublicScrollViewportBlockSize } from '../../../internal/semanticSizing';
+export interface Props {
+    accessibleLabel: string;
+    axis?: PublicSScrollViewportAxis;
+    blockSize?: PublicScrollViewportBlockSize;
+    focusable?: boolean;
+    keyboardNavigation?: boolean;
+    overscrollBehavior?: PublicSScrollViewportOverscrollBehavior;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<Props, SScrollViewportApi, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "scroll-state": (state: SScrollViewportState) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onScroll-state"?: ((state: SScrollViewportState) => any) | undefined;
+}>, {
+    focusable: boolean;
+    blockSize: PublicScrollViewportBlockSize;
+    overscrollBehavior: PublicSScrollViewportOverscrollBehavior;
+    axis: PublicSScrollViewportAxis;
+    keyboardNavigation: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/shared/data-display/SScrollViewport.vue.js

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

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

@@ -0,0 +1,273 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { validateBoolean as t, validateBoundedNumber as n, validateExactString as r, validateNonEmptyString as i } from "../../../internal/runtimeContract.js";
+import { useInteractiveLeafRegistration as a } from "../../../internal/passiveContentContract.js";
+import { validateScrollViewportBlockSize as o } from "../../../internal/semanticSizing.js";
+import { computed as s, createElementBlock as c, createElementVNode as l, defineComponent as u, mergeProps as d, nextTick as f, onBeforeUnmount as p, onMounted as m, openBlock as h, renderSlot as g, shallowRef as _, unref as v, watch as y } from "vue";
+//#region src/components/shared/data-display/SScrollViewport.vue?vue&type=script&setup=true&lang.ts
+var b = [
+	"aria-label",
+	"tabindex",
+	"data-axis",
+	"data-block-size",
+	"data-focusable",
+	"data-keyboard-navigation",
+	"data-overscroll-behavior",
+	"data-at-inline-start",
+	"data-at-inline-end",
+	"data-at-block-start",
+	"data-at-block-end"
+], x = /*@__PURE__*/ u({
+	inheritAttrs: !1,
+	__name: "SScrollViewport",
+	props: {
+		accessibleLabel: {},
+		axis: { default: "y" },
+		blockSize: { default: "md" },
+		focusable: {
+			type: Boolean,
+			default: !0
+		},
+		keyboardNavigation: {
+			type: Boolean,
+			default: !0
+		},
+		overscrollBehavior: { default: "contain" }
+	},
+	emits: ["scroll-state"],
+	setup(u, { expose: x, emit: S }) {
+		let C = u, w = S, T = _(null), E = _(null), D = _(null), O = e({
+			component: "SScrollViewport",
+			owner: "scroll viewport region"
+		}), k = null, A = "", j = null, M = s(() => {
+			let e = t("SScrollViewport", "focusable", C.focusable), n = t("SScrollViewport", "keyboardNavigation", C.keyboardNavigation);
+			if (n && !e) throw Error("SScrollViewport: keyboardNavigation=true требует focusable=true. / SScrollViewport: keyboardNavigation=true requires focusable=true.");
+			return {
+				accessibleLabel: i("SScrollViewport", "accessibleLabel", C.accessibleLabel),
+				axis: r("SScrollViewport", "axis", C.axis, [
+					"x",
+					"y",
+					"both"
+				]),
+				blockSize: o("SScrollViewport", "blockSize", C.blockSize),
+				focusable: e,
+				keyboardNavigation: n,
+				overscrollBehavior: r("SScrollViewport", "overscrollBehavior", C.overscrollBehavior, [
+					"auto",
+					"contain",
+					"none"
+				])
+			};
+		});
+		a({
+			owner: "SScrollViewport",
+			active: () => M.value.focusable
+		});
+		function N(e, t) {
+			return Math.min(t, Math.max(0, e));
+		}
+		function P(e) {
+			if (j) return j;
+			let t = e.ownerDocument, n = t.createElement("div"), r = t.createElement("div");
+			return n.dir = "rtl", n.style.cssText = "position:absolute;inset:-9999px;width:4px;height:1px;overflow:scroll;", r.style.cssText = "width:8px;height:1px;", n.append(r), t.body.append(n), n.scrollLeft > 0 ? j = "default" : (n.scrollLeft = 1, j = n.scrollLeft === 0 ? "negative" : "reverse"), n.remove(), j;
+		}
+		function F(e, t) {
+			let n = e.scrollLeft;
+			if (getComputedStyle(e).direction !== "rtl") return N(n, t);
+			switch (P(e)) {
+				case "negative": return N(t + n, t);
+				case "reverse": return N(t - n, t);
+				case "default": return N(n, t);
+			}
+		}
+		function I(e, t, n) {
+			let r = N(t, n);
+			if (getComputedStyle(e).direction !== "rtl") return r;
+			switch (P(e)) {
+				case "negative": return r - n;
+				case "reverse": return n - r;
+				case "default": return r;
+			}
+		}
+		function L(e, t) {
+			let n = getComputedStyle(e);
+			return n.writingMode.startsWith("vertical") || n.writingMode.startsWith("sideways") ? Object.freeze({
+				inline: n.direction === "rtl" ? t.maxY - t.y : t.y,
+				block: n.writingMode.endsWith("-rl") ? t.maxX - t.x : t.x,
+				maxInline: t.maxY,
+				maxBlock: t.maxX
+			}) : Object.freeze({
+				inline: n.direction === "rtl" ? t.maxX - t.x : t.x,
+				block: t.y,
+				maxInline: t.maxX,
+				maxBlock: t.maxY
+			});
+		}
+		function R(e) {
+			let t = Math.max(0, e.scrollWidth - e.clientWidth), n = Math.max(0, e.scrollHeight - e.clientHeight), r = Object.freeze({
+				x: F(e, t),
+				y: N(e.scrollTop, n),
+				maxX: t,
+				maxY: n
+			}), i = L(e, r);
+			return Object.freeze({
+				physical: r,
+				semantic: i,
+				atInlineStart: i.inline <= 1,
+				atInlineEnd: i.maxInline - i.inline <= 1,
+				atBlockStart: i.block <= 1,
+				atBlockEnd: i.maxBlock - i.block <= 1
+			});
+		}
+		function z() {
+			let e = T.value;
+			if (!e) return;
+			let t = R(e), n = JSON.stringify(t);
+			n !== A && (A = n, D.value = t, w("scroll-state", t));
+		}
+		function B(e) {
+			let t = T.value;
+			if (t) return t;
+			throw Error(`SScrollViewport: ${e} недоступен до mount. / SScrollViewport: ${e} is unavailable before mount.`);
+		}
+		function V(e) {
+			return M.value.axis === e || M.value.axis === "both";
+		}
+		function H(e, t) {
+			if (!V(e)) throw Error(`SScrollViewport: ${t} не может управлять осью ${e} при axis=${M.value.axis}. / SScrollViewport: ${t} cannot control axis ${e} when axis=${M.value.axis}.`);
+		}
+		function U() {
+			if (!M.value.focusable) throw Error("SScrollViewport: focus() требует focusable=true. / SScrollViewport: focus() requires focusable=true.");
+			B("focus()").focus();
+		}
+		function W(e, t) {
+			let n = r("SScrollViewport", "scrollToBoundary.axis", e, ["x", "y"]), i = r("SScrollViewport", "scrollToBoundary.boundary", t, ["start", "end"]);
+			H(n, "scrollToBoundary()");
+			let a = B("scrollToBoundary()"), o = R(a).physical, s = n === "x" ? i === "start" ? 0 : o.maxX : o.x, c = n === "y" ? i === "start" ? 0 : o.maxY : o.y;
+			a.scrollTo({
+				left: I(a, s, o.maxX),
+				top: c,
+				behavior: "auto"
+			}), z();
+		}
+		function G(e) {
+			if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError("SScrollViewport: reveal.options должен быть объектом. / SScrollViewport: reveal.options must be an object.");
+			if (e.x === void 0 && e.y === void 0) throw Error("SScrollViewport: reveal() требует x и/или y. / SScrollViewport: reveal() requires x and/or y.");
+			e.x !== void 0 && H("x", "reveal()"), e.y !== void 0 && H("y", "reveal()");
+			let t = B("reveal()"), i = R(t).physical, a = e.x === void 0 ? i.x : n("SScrollViewport", "reveal.x", e.x, {
+				minimum: 0,
+				maximum: 2 ** 53 - 1
+			}), o = e.y === void 0 ? i.y : n("SScrollViewport", "reveal.y", e.y, {
+				minimum: 0,
+				maximum: 2 ** 53 - 1
+			}), s = r("SScrollViewport", "reveal.behavior", e.behavior ?? "auto", ["auto", "smooth"]);
+			t.scrollTo({
+				left: I(t, a, i.maxX),
+				top: N(o, i.maxY),
+				behavior: s
+			}), z();
+		}
+		function K(e, t) {
+			let n = V("x"), r = V("y"), i = Math.max(1, e.clientWidth / 8), a = Math.max(1, e.clientHeight / 8), o = Math.max(1, e.clientWidth * .9), s = Math.max(1, e.clientHeight * .9), c = R(e).physical;
+			switch (t.key) {
+				case "ArrowLeft": return n ? {
+					left: c.x - i,
+					top: c.y
+				} : null;
+				case "ArrowRight": return n ? {
+					left: c.x + i,
+					top: c.y
+				} : null;
+				case "ArrowUp": return r ? {
+					left: c.x,
+					top: c.y - a
+				} : null;
+				case "ArrowDown": return r ? {
+					left: c.x,
+					top: c.y + a
+				} : null;
+				case "PageUp": return r ? {
+					left: c.x,
+					top: c.y - s
+				} : n ? {
+					left: c.x - o,
+					top: c.y
+				} : null;
+				case "PageDown": return r ? {
+					left: c.x,
+					top: c.y + s
+				} : n ? {
+					left: c.x + o,
+					top: c.y
+				} : null;
+				case "Home": return {
+					left: n ? 0 : c.x,
+					top: r ? 0 : c.y
+				};
+				case "End": return {
+					left: n ? c.maxX : c.x,
+					top: r ? c.maxY : c.y
+				};
+				default: return null;
+			}
+		}
+		function q(e) {
+			let t = T.value;
+			if (!t || !M.value.keyboardNavigation || e.target !== t || e.defaultPrevented || e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
+			let n = K(t, e);
+			if (!n) return;
+			e.preventDefault();
+			let r = R(t).physical;
+			t.scrollTo({
+				left: I(t, n.left, r.maxX),
+				top: N(n.top, r.maxY),
+				behavior: "auto"
+			}), z();
+		}
+		function J() {
+			z();
+		}
+		return m(() => {
+			let e = B("observer setup"), t = E.value;
+			if (!t) throw Error("SScrollViewport: content owner отсутствует после mount. / SScrollViewport: content owner is missing after mount.");
+			if (typeof ResizeObserver > "u") throw Error("SScrollViewport: runtime требует ResizeObserver. / SScrollViewport: runtime requires ResizeObserver.");
+			e.addEventListener("scroll", J, { passive: !0 }), k = new ResizeObserver(z), k.observe(e), k.observe(t), z();
+		}), y(() => [
+			M.value.axis,
+			M.value.blockSize,
+			M.value.focusable,
+			M.value.keyboardNavigation,
+			M.value.overscrollBehavior
+		], async () => {
+			await f(), z();
+		}), p(() => {
+			T.value?.removeEventListener("scroll", J), k?.disconnect(), k = null, A = "";
+		}), x({
+			focus: U,
+			scrollToBoundary: W,
+			reveal: G
+		}), (e, t) => (h(), c("div", d(v(O).bindings(), {
+			ref_key: "viewportRef",
+			ref: T,
+			class: "s-scroll-viewport",
+			role: "region",
+			"aria-label": M.value.accessibleLabel,
+			tabindex: M.value.focusable ? 0 : void 0,
+			"data-axis": M.value.axis,
+			"data-block-size": M.value.blockSize,
+			"data-focusable": M.value.focusable,
+			"data-keyboard-navigation": M.value.keyboardNavigation,
+			"data-overscroll-behavior": M.value.overscrollBehavior,
+			"data-at-inline-start": D.value?.atInlineStart,
+			"data-at-inline-end": D.value?.atInlineEnd,
+			"data-at-block-start": D.value?.atBlockStart,
+			"data-at-block-end": D.value?.atBlockEnd,
+			onKeydown: q
+		}), [l("div", {
+			ref_key: "contentRef",
+			ref: E,
+			class: "s-scroll-viewport__content"
+		}, [g(e.$slots, "default", {}, void 0, !0)], 512)], 16, b));
+	}
+});
+//#endregion
+export { x as default };

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

@@ -0,0 +1,39 @@
+type __VLS_Props = {
+    title: string;
+    eyebrow?: string | null;
+    description?: string | null;
+    meta?: string | null;
+    headingLevel?: 2 | 3 | 4;
+    size?: 'sm' | 'md';
+    variant?: 'default' | 'display';
+    divider?: boolean;
+    padding?: 'none' | 'sm' | 'md';
+    spacingAfter?: 'none' | 'sm' | 'md';
+    trailingLayout?: 'responsive' | 'inline' | 'stacked';
+};
+declare var __VLS_9: {}, __VLS_12: {};
+type __VLS_Slots = {} & {
+    badges?: (props: typeof __VLS_9) => any;
+} & {
+    actions?: (props: typeof __VLS_12) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    meta: string | null;
+    size: "sm" | "md";
+    variant: "default" | "display";
+    description: string | null;
+    padding: "none" | "sm" | "md";
+    trailingLayout: "responsive" | "inline" | "stacked";
+    divider: boolean;
+    headingLevel: 2 | 3 | 4;
+    eyebrow: string | null;
+    spacingAfter: "none" | "sm" | "md";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/shared/data-display/SSectionHeader.vue.js

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

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

@@ -0,0 +1,66 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import t from "../_internal/SHeaderSurface.vue.js";
+import { createBlock as n, createSlots as r, defineComponent as i, mergeProps as a, openBlock as o, renderSlot as s, unref as c, withCtx as l } from "vue";
+//#region src/components/shared/data-display/SSectionHeader.vue?vue&type=script&setup=true&lang.ts
+var u = /*@__PURE__*/ i({
+	inheritAttrs: !1,
+	__name: "SSectionHeader",
+	props: {
+		title: {},
+		eyebrow: { default: void 0 },
+		description: { default: void 0 },
+		meta: { default: void 0 },
+		headingLevel: { default: 3 },
+		size: { default: "md" },
+		variant: { default: "default" },
+		divider: {
+			type: Boolean,
+			default: !1
+		},
+		padding: { default: "none" },
+		spacingAfter: { default: "none" },
+		trailingLayout: { default: "responsive" }
+	},
+	setup(i) {
+		let u = e({
+			component: "SSectionHeader",
+			owner: "section header root"
+		});
+		return (e, d) => (o(), n(t, a(c(u).bindings(), {
+			kind: "section",
+			title: i.title,
+			eyebrow: i.eyebrow,
+			description: i.description,
+			meta: i.meta,
+			"heading-level": i.headingLevel,
+			size: i.size,
+			variant: i.variant,
+			divider: i.divider,
+			padding: i.padding,
+			"spacing-after": i.spacingAfter,
+			"trailing-layout": i.trailingLayout
+		}), r({ _: 2 }, [e.$slots.badges ? {
+			name: "badges",
+			fn: l(() => [s(e.$slots, "badges")]),
+			key: "0"
+		} : void 0, e.$slots.actions ? {
+			name: "actions",
+			fn: l(() => [s(e.$slots, "actions")]),
+			key: "1"
+		} : void 0]), 1040, [
+			"title",
+			"eyebrow",
+			"description",
+			"meta",
+			"heading-level",
+			"size",
+			"variant",
+			"divider",
+			"padding",
+			"spacing-after",
+			"trailing-layout"
+		]));
+	}
+});
+//#endregion
+export { u as default };

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

@@ -0,0 +1,34 @@
+import { Component } from 'vue';
+import { FeedbackLiveMode, FeedbackTone } from '../../../internal/feedbackPresentation';
+export type StatusTone = FeedbackTone;
+export type StatusAppearance = 'text' | 'soft';
+export type StatusSize = 'xs' | 'sm' | 'md';
+export type StatusLiveMode = Exclude<FeedbackLiveMode, 'auto'>;
+export interface StatusPresentation {
+    label: string;
+    tone?: StatusTone;
+    title?: string;
+    icon?: Component | null;
+}
+type __VLS_Props = {
+    label: string;
+    tone?: StatusTone;
+    appearance?: StatusAppearance;
+    size?: StatusSize;
+    /** Видимость текстовой подписи при сохранении accessible name. / Text-label visibility while preserving the accessible name. */
+    labelVisibility?: 'visible' | 'sr-only';
+    title?: string;
+    icon?: Component | null;
+    live?: StatusLiveMode;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    title: string;
+    size: StatusSize;
+    icon: Component | null;
+    tone: StatusTone;
+    live: StatusLiveMode;
+    appearance: StatusAppearance;
+    labelVisibility: "visible" | "sr-only";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/shared/data-display/SStatus.vue.js

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

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

@@ -0,0 +1,58 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import { resolveSemanticToneBinding as t } from "../../../internal/semanticTone.js";
+import { resolveFeedbackLive as n, resolveFeedbackPresentation as r } from "../../../internal/feedbackPresentation.js";
+import { computed as i, createBlock as a, createCommentVNode as o, createElementBlock as s, createElementVNode as c, defineComponent as l, markRaw as u, mergeProps as d, openBlock as f, resolveDynamicComponent as p, toDisplayString as m, toRaw as h, unref as g } from "vue";
+//#region src/components/shared/data-display/SStatus.vue?vue&type=script&setup=true&lang.ts
+var _ = [
+	"data-s-tone",
+	"data-appearance",
+	"data-size",
+	"data-label-visibility",
+	"title",
+	"role",
+	"aria-live",
+	"aria-atomic"
+], v = {
+	key: 0,
+	class: "s-status__icon",
+	"aria-hidden": "true"
+}, y = { class: "s-status__label" }, b = /*@__PURE__*/ l({
+	inheritAttrs: !1,
+	__name: "SStatus",
+	props: {
+		label: {},
+		tone: { default: "neutral" },
+		appearance: { default: "text" },
+		size: { default: "md" },
+		labelVisibility: { default: "visible" },
+		title: { default: void 0 },
+		icon: { default: void 0 },
+		live: { default: "off" }
+	},
+	setup(l) {
+		let b = [
+			"neutral",
+			"info",
+			"success",
+			"warn",
+			"danger"
+		], x = l, S = i(() => r(x.tone).icon), C = e({
+			component: "SStatus",
+			owner: "status root"
+		}), w = i(() => t("SStatus", "tone", x.tone, b)), T = i(() => n(x.tone, x.live)), E = i(() => x.icon === null ? null : u(h(x.icon ?? S.value)));
+		return (e, t) => (f(), s("span", d(g(C).bindings(), {
+			"data-s-tone": w.value["data-s-tone"],
+			class: "s-status",
+			"data-appearance": l.appearance,
+			"data-size": l.size,
+			"data-label-visibility": l.labelVisibility,
+			title: l.title,
+			role: T.value.role,
+			"aria-live": T.value.ariaLive,
+			"aria-atomic": T.value.ariaAtomic,
+			"data-testid": "s-status"
+		}), [E.value ? (f(), s("span", v, [(f(), a(p(E.value), { class: "s-status__icon-graphic" }))])) : o("", !0), c("span", y, m(l.label), 1)], 16, _));
+	}
+});
+//#endregion
+export { b as default };

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

@@ -0,0 +1,92 @@
+import { ScrollableViewportMaxBlockSize } from '../../../internal/semanticSizing';
+import { STableCellState, STableColumn, STableDensity, STableMinWidth, STableRowKey, STableRowState, STableSelectionMode, STableSort, STableSortMode, STableSurface } from './table';
+export type { STableAlignment, STableCellState, STableColumn, STableColumnContent, STableColumnHeaderPresentation, STableDensity, STableMinWidth, STableRowKey, STableRowState, STableSelectionMode, STableSort, STableSortDirection, STableSortMode, STableSurface, } from './table';
+/** Публичный generic-контракт таблицы принадлежит source-SFC runtime. / The public generic table contract is owned by the source-SFC runtime. */
+export interface STableProps<Row extends object, RowKey extends STableRowKey, Field extends string> {
+    columns: readonly STableColumn<Row, Field>[];
+    data: readonly Row[];
+    getRowKey: (row: Row) => RowKey;
+    loading?: boolean;
+    loadingMessage?: string;
+    errorMessage?: string;
+    emptyMessage?: string;
+    selectedRowKey?: RowKey;
+    selectionMode?: STableSelectionMode;
+    selectedRowKeys?: readonly RowKey[];
+    isRowSelectable?: (row: Row, index: number) => boolean;
+    expandedRowKeys?: readonly RowKey[];
+    isRowExpandable?: (row: Row, index: number) => boolean;
+    getRowLabel?: (row: Row, index: number) => string;
+    sortMode?: STableSortMode;
+    sort?: STableSort<Field> | null;
+    sorts?: readonly STableSort<Field>[];
+    maxHeight?: ScrollableViewportMaxBlockSize;
+    density?: STableDensity;
+    surface?: STableSurface;
+    minWidth?: STableMinWidth;
+    rowState?: (row: Row) => STableRowState;
+    cellState?: (row: Row, column: STableColumn<Row, Field>) => STableCellState;
+    /** Accessible name без visible owner. / Accessible name when there is no visible owner. */
+    ariaLabel?: string;
+    /** DOM id visible owner, mutually exclusive with ariaLabel. / DOM id of the visible owner, mutually exclusive with ariaLabel. */
+    ariaLabelledby?: string;
+    /** DOM id supplemental status/diagnostic owner. / DOM id of a supplemental status/diagnostic owner. */
+    ariaDescribedby?: string;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <Row extends object = Record<string, unknown>, RowKey extends STableRowKey = STableRowKey, Field extends string = Extract<keyof Row, 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<STableProps<Row, RowKey, Field> & {
+        onSort?: ((value: STableSort<Field> | null) => any) | undefined;
+        "onRow-click"?: ((row: Row, index: number) => any) | undefined;
+        "onRow-contextmenu"?: ((row: Row, index: number, event: MouseEvent) => any) | undefined;
+        "onUpdate:selectedRowKeys"?: ((value: readonly RowKey[]) => any) | undefined;
+        "onUpdate:expandedRowKeys"?: ((value: readonly RowKey[]) => any) | undefined;
+        "onRow-expand"?: ((row: Row, index: number, expanded: boolean) => any) | undefined;
+        "onUpdate:sort"?: ((value: STableSort<Field> | null) => any) | undefined;
+        "onUpdate:sorts"?: ((value: readonly STableSort<Field>[]) => any) | undefined;
+        "onMulti-sort"?: ((value: readonly STableSort<Field>[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: { [K in NonNullable<`header-${Field}` | `header-${Extract<keyof Row, string> & string}`>]?: ((props: {
+        column: STableColumn<Row, Field>;
+    }) => any) | undefined; } & { [K_1 in NonNullable<`header-${Field}` | `header-${Extract<keyof Row, string> & string}`>]?: ((props: {
+        column: STableColumn<Row, Field>;
+    }) => any) | undefined; } & { [K_2 in NonNullable<`cell-${Field}` | `cell-${Extract<keyof Row, string> & string}`>]?: ((props: {
+        value: unknown;
+        row: Row;
+        column: STableColumn<Row, Field>;
+        rowIndex: number;
+    }) => any) | undefined; } & {
+        column?: (props: {
+            column: STableColumn<Row, Field>;
+        }) => any;
+    } & {
+        column?: (props: {
+            column: STableColumn<Row, Field>;
+        }) => any;
+    } & {
+        cell?: (props: {
+            value: unknown;
+            row: Row;
+            column: STableColumn<Row, Field>;
+            rowIndex: number;
+        }) => any;
+    } & {
+        'row-details'?: (props: {
+            row: Row;
+            rowIndex: number;
+        }) => any;
+    };
+    emit: ((evt: "sort", value: STableSort<Field> | null) => void) & ((evt: "row-click", row: Row, index: number) => void) & ((evt: "row-contextmenu", row: Row, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", value: readonly RowKey[]) => void) & ((evt: "update:expandedRowKeys", value: readonly RowKey[]) => void) & ((evt: "row-expand", row: Row, index: number, expanded: boolean) => void) & ((evt: "update:sort", value: STableSort<Field> | null) => void) & ((evt: "update:sorts", value: readonly STableSort<Field>[]) => void) & ((evt: "multi-sort", value: readonly STableSort<Field>[]) => 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/data-display/STable.vue.js

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