@pgcorp/ui-kit 0.13.0 → 0.15.0

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

@@ -0,0 +1,21 @@
+import { VNodeChild } from 'vue';
+import { SRichSemanticTableCellContent, SRichSemanticTableNode, SRichTableNode } from '../richDocument';
+type __VLS_Props = {
+    node: SRichTableNode | SRichSemanticTableNode;
+    path: string;
+};
+type __VLS_Slots = {
+    content: (props: {
+        entry: SRichSemanticTableCellContent;
+        path: string;
+    }) => VNodeChild;
+};
+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/data-display/_internal/SRichTableNode.vue.js

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

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

@@ -0,0 +1,150 @@
+import e from "./STableRow.vue.js";
+import t from "./STableCell.vue.js";
+import { useRichDocumentNavigation as n } from "./richDocumentNavigation.js";
+import { richMetadataOwnerBindings as r } from "./richDocumentMetadata.js";
+import i from "./STableFrame.vue.js";
+import a from "./STableSection.vue.js";
+import { Fragment as o, computed as s, createBlock as c, createElementBlock as l, createSlots as u, createTextVNode as d, createVNode as f, defineComponent as p, mergeProps as m, openBlock as h, renderList as g, renderSlot as _, toDisplayString as v, useId as y, useSlots as b, watchEffect as x, withCtx as S } from "vue";
+//#region src/components/shared/data-display/_internal/SRichTableNode.vue?vue&type=script&setup=true&lang.ts
+var C = /*@__PURE__*/ p({
+	inheritAttrs: !1,
+	__name: "SRichTableNode",
+	props: {
+		node: {},
+		path: {}
+	},
+	setup(p) {
+		let C = p, w = b(), T = n(), E = y(), D = s(() => C.node.type === "semanticTable" ? [
+			...C.node.head === void 0 ? [] : [{
+				kind: "head",
+				metadata: C.node.headMetadata ?? {},
+				rows: C.node.head
+			}],
+			{
+				kind: "body",
+				metadata: C.node.bodyMetadata ?? {},
+				rows: C.node.body
+			},
+			...C.node.foot === void 0 ? [] : [{
+				kind: "foot",
+				metadata: C.node.footMetadata ?? {},
+				rows: C.node.foot
+			}]
+		] : []);
+		function O(e) {
+			return JSON.stringify([E, e]);
+		}
+		function k(e) {
+			return e.cellId === void 0 || e.anchorId !== void 0 ? void 0 : {
+				kind: "cell",
+				identity: O(e.cellId)
+			};
+		}
+		let A = s(() => {
+			let e = /* @__PURE__ */ new Map();
+			for (let t of D.value) for (let n of t.rows) for (let t of n.cells) t.type === "header" && t.cellId !== void 0 && e.set(t.cellId, t.anchorId === void 0 ? T.domId("cell", O(t.cellId)) : T.domId("anchor", t.anchorId));
+			return e;
+		});
+		function j(e) {
+			return e?.map((e) => {
+				let t = A.value.get(e);
+				if (t === void 0) throw Error(`SRichTableNode: validated header ${JSON.stringify(e)} is unavailable.`);
+				return t;
+			});
+		}
+		function M(e, t) {
+			return r(e, T, t);
+		}
+		let N = s(() => C.node.accessibleLabel ?? (C.node.labelledBy === void 0 ? C.node.label : void 0));
+		function P(e) {
+			return e.accessibleLabel ?? (e.labelledBy === void 0 ? e.header : void 0);
+		}
+		function F(e) {
+			return {
+				content: "inline",
+				children: e
+			};
+		}
+		return x(() => {
+			if (typeof w.content != "function") throw Error("SRichTableNode: content slot must render the validated inline/block content.");
+		}), (n, r) => (h(), c(i, m(M(p.node), {
+			"aria-label": N.value,
+			"column-groups": p.node.type === "semanticTable" ? p.node.columnGroups?.map((e) => e.span) : void 0,
+			surface: "plain",
+			density: "compact",
+			"min-width": "content"
+		}), u({
+			default: S(() => [p.node.type === "table" ? (h(), l(o, { key: 0 }, [f(a, { kind: "head" }, {
+				default: S(() => [f(e, null, {
+					default: S(() => [(h(!0), l(o, null, g(p.node.columns, (e, r) => (h(), c(t, m({ key: e.id }, { ref_for: !0 }, M(e), {
+						kind: "header",
+						scope: "col",
+						align: e.align ?? "left",
+						"header-presentation": e.headerPresentation ?? "visible",
+						"aria-label": P(e)
+					}), {
+						default: S(() => [e.headerChildren === void 0 ? (h(), l(o, { key: 1 }, [d(v(e.header), 1)], 64)) : _(n.$slots, "content", {
+							entry: F(e.headerChildren),
+							path: `${p.path}.columns[${r}].headerChildren`
+						}, void 0, void 0, 0)]),
+						_: 2
+					}, 1040, [
+						"align",
+						"header-presentation",
+						"aria-label"
+					]))), 128))]),
+					_: 3
+				})]),
+				_: 3
+			}), f(a, { kind: "body" }, {
+				default: S(() => [(h(!0), l(o, null, g(p.node.rows, (r, i) => (h(), c(e, m({ key: r.id }, { ref_for: !0 }, M(r)), {
+					default: S(() => [(h(!0), l(o, null, g(r.cells, (e, r) => (h(), c(t, m({ key: p.node.columns[r].id }, { ref_for: !0 }, M(e), { align: p.node.columns[r].align ?? "left" }), {
+						default: S(() => [_(n.$slots, "content", {
+							entry: F(e.children),
+							path: `${p.path}.rows[${i}].cells[${r}].children`
+						})]),
+						_: 2
+					}, 1040, ["align"]))), 128))]),
+					_: 2
+				}, 1040))), 128))]),
+				_: 3
+			})], 64)) : (h(!0), l(o, { key: 1 }, g(D.value, (r) => (h(), c(a, m({ key: r.kind }, { ref_for: !0 }, M(r.metadata), { kind: r.kind }), {
+				default: S(() => [(h(!0), l(o, null, g(r.rows, (i, a) => (h(), c(e, m({ key: i.anchorId ?? a }, { ref_for: !0 }, M(i)), {
+					default: S(() => [(h(!0), l(o, null, g(i.cells, (e, i) => (h(), c(t, m({ key: e.cellId ?? e.anchorId ?? i }, { ref_for: !0 }, M(e, k(e)), {
+						kind: e.type,
+						scope: e.type === "header" ? e.scope : void 0,
+						"row-span": e.rowSpan,
+						"col-span": e.colSpan,
+						headers: j(e.headers),
+						align: e.align ?? "left"
+					}), {
+						default: S(() => [_(n.$slots, "content", {
+							entry: e,
+							path: `${p.path}.${r.kind}[${a}].cells[${i}].children`
+						})]),
+						_: 2
+					}, 1040, [
+						"kind",
+						"scope",
+						"row-span",
+						"col-span",
+						"headers",
+						"align"
+					]))), 128))]),
+					_: 2
+				}, 1040))), 128))]),
+				_: 2
+			}, 1040, ["kind"]))), 128))]),
+			_: 2
+		}, [p.node.type === "semanticTable" && p.node.caption !== void 0 ? {
+			name: "caption",
+			fn: S(() => [_(n.$slots, "content", {
+				entry: F(p.node.caption),
+				path: `${p.path}.caption`
+			})]),
+			key: "0"
+		} : void 0]), 1040, ["aria-label", "column-groups"]));
+	}
+});
+//#endregion
+export { C as default };

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

@@ -0,0 +1,52 @@
+import { ElementApi } from '../../../../internal/interactiveElement';
+import { TableColumnInlineSize, TableColumnMinInlineSize } from '../../../../internal/semanticSizing';
+import { STableAlignment, STableCellState } from '../table';
+import { STableCellPresentation } from './tableFoundation';
+type __VLS_Props = {
+    kind?: 'header' | 'data';
+    presentation?: STableCellPresentation;
+    align?: STableAlignment;
+    state?: STableCellState;
+    width?: TableColumnInlineSize;
+    minWidth?: TableColumnMinInlineSize;
+    scope?: 'row' | 'col' | 'rowgroup' | 'colgroup';
+    rowSpan?: number;
+    colSpan?: number;
+    headers?: readonly string[];
+    domId?: string;
+    focusTarget?: boolean;
+    sortable?: boolean;
+    sortDirection?: 'none' | 'ascending' | 'descending' | 'other';
+    headerPresentation?: 'visible' | 'assistive';
+    title?: string;
+    language?: string;
+    direction?: 'ltr' | 'rtl' | 'auto';
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+};
+declare var __VLS_8: {}, __VLS_10: {}, __VLS_12: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_10) => any;
+} & {
+    default?: (props: typeof __VLS_12) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, ElementApi<HTMLTableCellElement>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    presentation: STableCellPresentation;
+    state: STableCellState;
+    focusTarget: boolean;
+    kind: "header" | "data";
+    align: STableAlignment;
+    sortable: boolean;
+    headerPresentation: "visible" | "assistive";
+}, {}, {}, {}, 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/_internal/STableCell.vue.js

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

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

@@ -0,0 +1,148 @@
+import { validateBoolean as e, validateBoundedInteger as t, validateDomId as n, validateExactString as r } from "../../../../internal/runtimeContract.js";
+import { useOwnedAttrs as i } from "../../../../internal/ownedAttrs.js";
+import { tableRowKey as a, tableSectionKey as o, validateTableMetadata as s } from "./tableFoundation.js";
+import { validateTableColumnInlineSize as c, validateTableColumnMinInlineSize as l } from "../../../../internal/semanticSizing.js";
+import { computed as u, createBlock as d, createElementBlock as f, defineComponent as p, inject as m, mergeProps as h, openBlock as g, ref as _, renderSlot as v, resolveDynamicComponent as y, unref as b, watchEffect as x, withCtx as S } from "vue";
+//#region src/components/shared/data-display/_internal/STableCell.vue?vue&type=script&setup=true&lang.ts
+var C = {
+	key: 0,
+	class: "s-table-cell__control"
+}, w = {
+	key: 1,
+	class: "s-table-cell__assistive",
+	"data-header-presentation": "assistive"
+}, T = /*@__PURE__*/ p({
+	inheritAttrs: !1,
+	__name: "STableCell",
+	props: {
+		kind: { default: "data" },
+		presentation: { default: "default" },
+		align: { default: "left" },
+		state: { default: "default" },
+		width: {},
+		minWidth: {},
+		scope: {},
+		rowSpan: {},
+		colSpan: {},
+		headers: {},
+		domId: {},
+		focusTarget: {
+			type: Boolean,
+			default: !1
+		},
+		sortable: {
+			type: Boolean,
+			default: !1
+		},
+		sortDirection: {},
+		headerPresentation: { default: "visible" },
+		title: {},
+		language: {},
+		direction: {},
+		ariaLabel: {},
+		ariaLabelledby: {},
+		ariaDescribedby: {}
+	},
+	setup(p, { expose: T }) {
+		let E = p, D = i({
+			component: "STableCell",
+			owner: "canonical semantic table cell"
+		}), O = _(null), k = m(o, u(() => "body")), A = m(a, null), j = u(() => r("STableCell", "kind", E.kind, ["header", "data"])), M = u(() => r("STableCell", "presentation", E.presentation, [
+			"default",
+			"control",
+			"details"
+		])), N = u(() => r("STableCell", "align", E.align, [
+			"left",
+			"center",
+			"right"
+		])), P = u(() => r("STableCell", "state", E.state, ["default", "pending"])), F = u(() => E.width === void 0 ? void 0 : c("STableCell", "width", E.width)), I = u(() => E.minWidth === void 0 ? void 0 : l("STableCell", "minWidth", E.minWidth));
+		function L(e) {
+			if (e === null || e instanceof HTMLTableCellElement) O.value = e;
+			else throw TypeError("STableCell: ref must resolve to its native cell.");
+		}
+		return x(() => {
+			if (s("STableCell", E), e("STableCell", "sortable", E.sortable), E.rowSpan !== void 0 && t("STableCell", "rowSpan", E.rowSpan, {
+				minimum: 0,
+				maximum: 65534
+			}), E.colSpan !== void 0 && t("STableCell", "colSpan", E.colSpan, {
+				minimum: 1,
+				maximum: 1e3
+			}), E.scope !== void 0) {
+				if (j.value !== "header") throw TypeError("STableCell: scope requires a header cell.");
+				r("STableCell", "scope", E.scope, [
+					"row",
+					"col",
+					"rowgroup",
+					"colgroup"
+				]);
+			}
+			if (E.sortDirection !== void 0 && r("STableCell", "sortDirection", E.sortDirection, [
+				"none",
+				"ascending",
+				"descending",
+				"other"
+			]), r("STableCell", "headerPresentation", E.headerPresentation, ["visible", "assistive"]), E.headerPresentation === "assistive" && (j.value !== "header" || E.sortable)) throw TypeError("STableCell: assistive presentation requires a non-sortable header cell.");
+			if (E.headers !== void 0) {
+				if (!Array.isArray(E.headers)) throw TypeError("STableCell: headers must be an explicit DOM ID list.");
+				for (let [e, t] of E.headers.entries()) n("STableCell", `headers[${e}]`, t);
+			}
+		}), T({ getElement: () => {
+			if (!O.value) throw Error("STableCell: native cell is unavailable.");
+			return O.value;
+		} }), (e, t) => (g(), d(y(j.value === "header" ? "th" : "td"), h({ ref: L }, b(D).bindings(), {
+			class: "s-table-cell",
+			"data-section": b(k),
+			"data-kind": j.value,
+			"data-presentation": M.value,
+			"data-width": F.value,
+			"data-min-width": I.value,
+			"data-align": N.value,
+			"data-state": P.value,
+			"data-row-state": b(A)?.state.value,
+			"data-selected": b(A)?.selected.value || void 0,
+			"data-sortable": p.sortable || void 0,
+			"aria-sort": p.sortDirection,
+			id: p.domId,
+			scope: p.scope,
+			colspan: p.colSpan,
+			rowspan: p.rowSpan,
+			headers: p.headers?.join(" "),
+			tabindex: p.focusTarget ? -1 : void 0,
+			title: p.title,
+			lang: p.language,
+			dir: p.direction,
+			"aria-label": p.ariaLabel,
+			"aria-labelledby": p.ariaLabelledby,
+			"aria-describedby": p.ariaDescribedby
+		}), {
+			default: S(() => [M.value === "control" ? (g(), f("div", C, [v(e.$slots, "default", {}, void 0, !0)])) : p.headerPresentation === "assistive" ? (g(), f("span", w, [v(e.$slots, "default", {}, void 0, !0)])) : v(e.$slots, "default", {}, void 0, !0, 2)]),
+			_: 3
+		}, 16, [
+			"data-section",
+			"data-kind",
+			"data-presentation",
+			"data-width",
+			"data-min-width",
+			"data-align",
+			"data-state",
+			"data-row-state",
+			"data-selected",
+			"data-sortable",
+			"aria-sort",
+			"id",
+			"scope",
+			"colspan",
+			"rowspan",
+			"headers",
+			"tabindex",
+			"title",
+			"lang",
+			"dir",
+			"aria-label",
+			"aria-labelledby",
+			"aria-describedby"
+		]));
+	}
+});
+//#endregion
+export { T as default };

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

@@ -0,0 +1,42 @@
+import { ElementApi } from '../../../../internal/interactiveElement';
+import { ScrollableViewportMaxBlockSize } from '../../../../internal/semanticSizing';
+import { STableDensity, STableMinWidth, STableSurface } from '../table';
+type __VLS_Props = {
+    density?: STableDensity;
+    surface?: STableSurface;
+    minWidth?: STableMinWidth;
+    maxHeight?: ScrollableViewportMaxBlockSize;
+    busy?: boolean;
+    columnGroups?: readonly number[];
+    domId?: string;
+    focusTarget?: boolean;
+    title?: string;
+    language?: string;
+    direction?: 'ltr' | 'rtl' | 'auto';
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+};
+declare var __VLS_7: {}, __VLS_9: {};
+type __VLS_Slots = {} & {
+    caption?: (props: typeof __VLS_7) => any;
+} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, ElementApi<HTMLTableElement>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    busy: boolean;
+    density: STableDensity;
+    focusTarget: boolean;
+    surface: STableSurface;
+    minWidth: STableMinWidth;
+    maxHeight: ScrollableViewportMaxBlockSize;
+    columnGroups: readonly number[];
+}, {}, {}, {}, 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/_internal/STableFrame.vue.js

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

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

@@ -0,0 +1,114 @@
+import { validateBoolean as e, validateExactString as t } from "../../../../internal/runtimeContract.js";
+import { useUiKitLocale as n } from "../../../../composables/useUiKitLocale.js";
+import { useOwnedAttrs as r } from "../../../../internal/ownedAttrs.js";
+import { validateTableMetadata as i } from "./tableFoundation.js";
+import { validateScrollableViewportMaxBlockSize as a } from "../../../../internal/semanticSizing.js";
+import o from "../SScrollViewport.vue.js";
+import { Fragment as s, computed as c, createCommentVNode as l, createElementBlock as u, createElementVNode as d, createVNode as f, defineComponent as p, mergeProps as m, openBlock as h, ref as g, renderList as _, renderSlot as v, unref as y, watchEffect as b, withCtx as x } from "vue";
+//#region src/components/shared/data-display/_internal/STableFrame.vue?vue&type=script&setup=true&lang.ts
+var S = [
+	"data-surface",
+	"data-min-width",
+	"data-max-height"
+], C = [
+	"data-density",
+	"id",
+	"tabindex",
+	"title",
+	"lang",
+	"dir",
+	"aria-label",
+	"aria-labelledby",
+	"aria-describedby",
+	"aria-busy"
+], w = {
+	key: 0,
+	class: "s-table__caption"
+}, T = ["span"], E = /*@__PURE__*/ p({
+	inheritAttrs: !1,
+	__name: "STableFrame",
+	props: {
+		density: { default: "default" },
+		surface: { default: "bordered" },
+		minWidth: { default: "content" },
+		maxHeight: { default: "none" },
+		busy: {
+			type: Boolean,
+			default: !1
+		},
+		columnGroups: { default: () => [] },
+		domId: {},
+		focusTarget: {
+			type: Boolean,
+			default: !1
+		},
+		title: {},
+		language: {},
+		direction: {},
+		ariaLabel: {},
+		ariaLabelledby: {},
+		ariaDescribedby: {}
+	},
+	setup(p, { expose: E }) {
+		let D = p, O = r({
+			component: "STableFrame",
+			owner: "canonical table scroll surface"
+		}), { t: k } = n(), A = c(() => D.ariaLabelledby === void 0 ? D.ariaLabel ?? k("table.accessibleName") : void 0), j = g(null), M = c(() => t("STableFrame", "density", D.density, ["default", "compact"])), N = c(() => t("STableFrame", "surface", D.surface, ["bordered", "plain"])), P = c(() => t("STableFrame", "minWidth", D.minWidth, [
+			"content",
+			"md",
+			"lg"
+		])), F = c(() => a("STableFrame", "maxHeight", D.maxHeight));
+		function I(e) {
+			if (e === null || e instanceof HTMLTableElement) j.value = e;
+			else throw TypeError("STableFrame: ref must resolve to its native table.");
+		}
+		return b(() => {
+			e("STableFrame", "busy", D.busy), i("STableFrame", D);
+			for (let e of D.columnGroups) if (!Number.isSafeInteger(e) || e < 1 || e > 1e3) throw TypeError("STableFrame: column group span must be an integer from 1 to 1000");
+		}), E({ getElement: () => {
+			if (!j.value) throw Error("STableFrame: native table is unavailable.");
+			return j.value;
+		} }), (e, t) => (h(), u("div", m(y(O).bindings(), {
+			class: "s-table-wrapper",
+			"data-surface": N.value,
+			"data-min-width": P.value,
+			"data-max-height": F.value
+		}), [f(o, {
+			"accessible-label": A.value,
+			"accessible-labelledby": p.ariaLabelledby,
+			axis: "both",
+			"block-size": "content",
+			"focus-policy": "overflow",
+			"max-block-size": F.value
+		}, {
+			default: x(() => [d("table", {
+				ref: I,
+				class: "s-table",
+				"data-density": M.value,
+				id: p.domId,
+				tabindex: p.focusTarget ? -1 : void 0,
+				title: p.title,
+				lang: p.language,
+				dir: p.direction,
+				"aria-label": p.ariaLabel,
+				"aria-labelledby": p.ariaLabelledby,
+				"aria-describedby": p.ariaDescribedby,
+				"aria-busy": p.busy ? "true" : void 0
+			}, [
+				e.$slots.caption ? (h(), u("caption", w, [v(e.$slots, "caption", {}, void 0, !0)])) : l("", !0),
+				(h(!0), u(s, null, _(p.columnGroups, (e, t) => (h(), u("colgroup", {
+					key: t,
+					span: e
+				}, null, 8, T))), 128)),
+				v(e.$slots, "default", {}, void 0, !0)
+			], 8, C)]),
+			_: 3
+		}, 8, [
+			"accessible-label",
+			"accessible-labelledby",
+			"max-block-size"
+		])], 16, S));
+	}
+});
+//#endregion
+export { E as default };

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

@@ -0,0 +1,43 @@
+import { ElementApi } from '../../../../internal/interactiveElement';
+import { STableRowState } from '../table';
+import { STableRowMode, STableRowPresentation } from './tableFoundation';
+type __VLS_Props = {
+    mode?: STableRowMode;
+    presentation?: STableRowPresentation;
+    state?: STableRowState;
+    selected?: boolean;
+    ariaSelected?: 'true' | 'false';
+    domId?: string;
+    focusTarget?: boolean;
+    title?: string;
+    language?: string;
+    direction?: 'ltr' | 'rtl' | 'auto';
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, ElementApi<HTMLTableRowElement>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    contextmenu: (event: MouseEvent) => any;
+    activate: (event: MouseEvent | KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onContextmenu?: ((event: MouseEvent) => any) | undefined;
+    onActivate?: ((event: MouseEvent | KeyboardEvent) => any) | undefined;
+}>, {
+    selected: boolean;
+    mode: STableRowMode;
+    presentation: STableRowPresentation;
+    state: STableRowState;
+    focusTarget: boolean;
+}, {}, {}, {}, 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/_internal/STableRow.vue.js

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