@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/complex/SKanbanCard.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,75 @@
+import { useOwnedAttrs as e } from "../../../internal/ownedAttrs.js";
+import t from "../data-display/SActionCard.vue.js";
+import { computed as n, createBlock as r, createCommentVNode as i, createElementBlock as a, createElementVNode as o, createSlots as s, defineComponent as c, mergeProps as l, openBlock as u, renderSlot as d, toDisplayString as f, unref as p, withCtx as m } from "vue";
+//#region src/components/shared/complex/SKanbanCard.vue?vue&type=script&setup=true&lang.ts
+var h = { class: "s-kanban-card__content" }, g = { class: "s-kanban-card__copy" }, _ = { class: "s-kanban-card__title" }, v = {
+	key: 0,
+	class: "s-kanban-card__subtitle"
+}, y = {
+	key: 0,
+	class: "s-kanban-card__body"
+}, b = {
+	key: 1,
+	class: "s-kanban-card__meta"
+}, x = /*@__PURE__*/ c({
+	inheritAttrs: !1,
+	__name: "SKanbanCard",
+	props: {
+		title: {},
+		subtitle: { default: void 0 },
+		surface: { default: void 0 },
+		selected: {
+			type: Boolean,
+			default: !1
+		},
+		tone: { default: "default" },
+		density: { default: "comfortable" },
+		padding: { default: "sm" },
+		radius: { default: "md" },
+		fill: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["activate"],
+	setup(c, { emit: x }) {
+		let S = c, C = x, w = n(() => S.surface ?? { mode: "static" }), T = e({
+			component: "SKanbanCard",
+			owner: "canonical action-card surface"
+		});
+		function E(e) {
+			C("activate", e);
+		}
+		return (e, n) => (u(), r(t, l({ "data-testid": "s-kanban-card" }, p(T).bindings(), {
+			surface: w.value,
+			selected: c.selected,
+			tone: c.tone,
+			density: c.density,
+			padding: c.padding,
+			radius: c.radius,
+			fill: c.fill ? "container" : "content",
+			onActivate: E
+		}), s({
+			default: m(() => [o("div", h, [
+				o("span", g, [o("span", _, f(c.title), 1), c.subtitle ? (u(), a("span", v, f(c.subtitle), 1)) : i("", !0)]),
+				e.$slots.default ? (u(), a("span", y, [d(e.$slots, "default", {}, void 0, !0)])) : i("", !0),
+				e.$slots.meta ? (u(), a("span", b, [d(e.$slots, "meta", {}, void 0, !0)])) : i("", !0)
+			])]),
+			_: 2
+		}, [e.$slots.actions ? {
+			name: "actions",
+			fn: m(() => [d(e.$slots, "actions", {}, void 0, !0)]),
+			key: "0"
+		} : void 0]), 1040, [
+			"surface",
+			"selected",
+			"tone",
+			"density",
+			"padding",
+			"radius",
+			"fill"
+		]));
+	}
+});
+//#endregion
+export { x as default };

package/dist/src/components/shared/complex/SKanbanLane.vue.d.ts

@@ -0,0 +1,38 @@
+import { VNodeChild } from 'vue';
+/** Каноническая вертикальная lane-композиция поверх disclosure, stack и empty-state owners. / Canonical vertical lane composition over disclosure, stack, and empty-state owners. */
+export interface Props {
+    /** Пользовательская метка lane. / User-facing lane label. */
+    title: string;
+    /** Точное число элементов в lane. / Exact number of items in the lane. */
+    count: number;
+    /** Сообщение пустого состояния. / Empty-state message. */
+    emptyText?: string;
+    /** Начальное состояние uncontrolled disclosure. / Initial uncontrolled disclosure state. */
+    defaultOpen?: boolean;
+    /** Controlled disclosure state. / Controlled disclosure state. */
+    open?: boolean;
+    /** Семантическая плотность disclosure. / Semantic disclosure density. */
+    density?: 'comfortable' | 'compact' | 'dense';
+}
+type __VLS_Slots = {
+    /** Элементы lane; их presentation принадлежит переданным UI-kit owners. / Lane items whose presentation belongs to supplied UI-kit owners. */
+    default?: () => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    emptyText: string;
+    open: boolean;
+    density: "comfortable" | "compact" | "dense";
+    defaultOpen: 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/complex/SKanbanLane.vue.js

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

package/dist/src/components/shared/complex/SKanbanLane.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,73 @@
+import { useUiKitLocale as e } from "../../../composables/useUiKitLocale.js";
+import { useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { validateBoundedInteger as n, validateNonEmptyString as r } from "../../../internal/runtimeContract.js";
+import i from "../data-display/SEmptyState.vue.js";
+import a from "../../layout/SStack.vue.js";
+import o from "../containers/SCollapsiblePanel.vue.js";
+import { computed as s, createBlock as c, defineComponent as l, mergeProps as u, openBlock as d, renderSlot as f, unref as p, withCtx as m } from "vue";
+//#region src/components/shared/complex/SKanbanLane.vue?vue&type=script&setup=true&lang.ts
+var h = /*@__PURE__*/ l({
+	inheritAttrs: !1,
+	__name: "SKanbanLane",
+	props: {
+		title: {},
+		count: {},
+		emptyText: { default: void 0 },
+		defaultOpen: {
+			type: Boolean,
+			default: !0
+		},
+		open: {
+			type: Boolean,
+			default: void 0
+		},
+		density: { default: "compact" }
+	},
+	emits: ["update:open"],
+	setup(l) {
+		let h = l, { t: g } = e(), _ = s(() => r("SKanbanLane", "title", h.title)), v = s(() => n("SKanbanLane", "count", h.count, {
+			minimum: 0,
+			maximum: 2 ** 53 - 1
+		})), y = s(() => r("SKanbanLane", "emptyText", h.emptyText ?? g("kanban.empty"))), b = t({
+			component: "SKanbanLane",
+			owner: "collapsible lane composition"
+		});
+		return (e, t) => (d(), c(o, u(p(b).bindings(), {
+			summary: _.value,
+			"summary-typography": "strong",
+			"summary-badges": [{
+				id: "item-count",
+				label: v.value,
+				severity: "secondary"
+			}],
+			open: l.open,
+			"default-open": l.defaultOpen,
+			density: l.density,
+			"header-variant": "minimal",
+			surface: "plain",
+			"onUpdate:open": t[0] ||= (t) => e.$emit("update:open", t),
+			"data-testid": "s-kanban-lane"
+		}), {
+			default: m(() => [v.value > 0 ? (d(), c(a, {
+				key: 0,
+				gap: "control"
+			}, {
+				default: m(() => [f(e.$slots, "default")]),
+				_: 3
+			})) : (d(), c(i, {
+				key: 1,
+				title: y.value,
+				size: "sm"
+			}, null, 8, ["title"]))]),
+			_: 3
+		}, 16, [
+			"summary",
+			"summary-badges",
+			"open",
+			"default-open",
+			"density"
+		]));
+	}
+});
+//#endregion
+export { h as default };

package/dist/src/components/shared/complex/STree.vue.d.ts

@@ -0,0 +1,45 @@
+import { STreeNodeContentScope, TreeNodeActivationEvent, TreeNodeEvent, SelectionKey, TreeActionsLayout, TreeDensity, TreeExpandControl, TreeModel, TreeRowVariant, TreeSelection, TreeSelectionRail } from './types';
+/** Публичный контракт дерева принадлежит source-SFC runtime. / The public tree contract is owned by the source-SFC runtime. */
+export interface STreeProps<T extends object, K extends SelectionKey = SelectionKey> {
+    nodes: readonly T[];
+    model: TreeModel<T, K>;
+    label: string;
+    selection: TreeSelection<K>;
+    expanded?: ReadonlySet<K>;
+    density?: TreeDensity;
+    actionsLayout?: TreeActionsLayout;
+    expandControl?: TreeExpandControl;
+    selectionRail?: TreeSelectionRail;
+    rowVariant?: TreeRowVariant;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends object, K extends SelectionKey>(__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<STreeProps<T, K> & {
+        "onUpdate:selection"?: ((selection: TreeSelection<K>) => any) | undefined;
+        "onUpdate:expanded"?: ((expanded: Set<K>) => any) | undefined;
+        "onNode-activate"?: ((event: TreeNodeActivationEvent<T, K>) => any) | undefined;
+        "onNode-select"?: ((event: TreeNodeEvent<T, K>) => any) | undefined;
+        "onNode-expand"?: ((event: TreeNodeEvent<T, K>) => any) | undefined;
+        "onNode-collapse"?: ((event: TreeNodeEvent<T, K>) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        'col-left': (props: STreeNodeContentScope<T, K>) => unknown;
+        'col-center': (props: STreeNodeContentScope<T, K>) => unknown;
+        meta: (props: STreeNodeContentScope<T, K>) => unknown;
+        'persistent-actions': (props: STreeNodeContentScope<T, K>) => unknown;
+        actions: (props: STreeNodeContentScope<T, K>) => unknown;
+    };
+    emit: ((evt: "update:selection", selection: TreeSelection<K>) => void) & ((evt: "update:expanded", expanded: Set<K>) => void) & ((evt: "node-activate", event: TreeNodeActivationEvent<T, K>) => void) & ((evt: "node-select", event: TreeNodeEvent<T, K>) => void) & ((evt: "node-expand", event: TreeNodeEvent<T, K>) => void) & ((evt: "node-collapse", event: TreeNodeEvent<T, K>) => 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/complex/STree.vue.js

@@ -0,0 +1,7 @@
+import "../../../../assets/src/components/shared/complex/STree.css_vue_type_style_index_0_src_true_lang.css";
+import e from "./STree.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                               */
+//#region src/components/shared/complex/STree.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/src/components/shared/complex/STree.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,223 @@
+import { lastItem as e } from "../../../internal/es2020.js";
+import { useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { TREE_RUNTIME_KEY as n, TreeItemRegistrationStore as r } from "../_internal/treeRuntime.js";
+import { assertSelectionKey as i, selectionKeyToken as a } from "../_internal/useSelectionRoving.js";
+import o from "../_internal/STreeNode.vue.js";
+import { validateTreeModel as s } from "./treeAdapter.js";
+import { Fragment as c, computed as l, createBlock as u, createElementBlock as d, createSlots as f, defineComponent as p, mergeProps as m, nextTick as h, openBlock as g, provide as _, ref as v, renderList as y, renderSlot as b, unref as x, watch as S, withCtx as C } from "vue";
+//#region src/components/shared/complex/STree.vue?vue&type=script&setup=true&lang.ts
+var w = ["aria-label", "aria-multiselectable"], T = /*@__PURE__*/ p({
+	inheritAttrs: !1,
+	__name: "STree",
+	props: {
+		nodes: {},
+		model: {},
+		label: {},
+		selection: {},
+		expanded: { default: () => /* @__PURE__ */ new Set() },
+		density: { default: "regular" },
+		actionsLayout: { default: "reserved" },
+		expandControl: { default: "button" },
+		selectionRail: { default: "hidden" },
+		rowVariant: { default: "default" }
+	},
+	emits: [
+		"update:selection",
+		"update:expanded",
+		"node-activate",
+		"node-select",
+		"node-expand",
+		"node-collapse"
+	],
+	setup(p, { emit: T }) {
+		let E = p, D = T, O = t({
+			component: "STree",
+			owner: "role=tree root"
+		}), k = v(null), A = v(), j = new r(() => k.value), M = "", N;
+		function P(e, t, n) {
+			if (i("STree", e, t), !n.has(e)) {
+				let n = a("STree", e, t);
+				throw Error(`STree: key ${n} из ${t} отсутствует в текущем inventory модели. / STree: ${t} key ${n} is absent from the current model inventory.`);
+			}
+		}
+		function F(e) {
+			let t = E.selection;
+			if (t.mode === "single" && t.key !== null && P(t.key, "selection.key", e), t.mode === "multiple") {
+				if (!(t.keys instanceof Set)) throw TypeError("STree: selection.keys must be a Set");
+				t.keys.forEach((t) => P(t, "selection.keys", e));
+			}
+			if (!(E.expanded instanceof Set)) throw TypeError("STree: expanded must be a Set");
+			E.expanded.forEach((t) => P(t, "expanded", e));
+		}
+		let I = l(() => (F(s(E.nodes, E.model)), E.nodes));
+		function L(e) {
+			j.register(e), A.value === void 0 && !e.disabled() && (A.value = e.key);
+		}
+		function R(e) {
+			j.unregister(e), A.value === e && (A.value = void 0, h(() => {
+				A.value = j.ordered().find((e) => !e.disabled())?.key;
+			}));
+		}
+		function z() {
+			return j.ordered();
+		}
+		async function B(e) {
+			e && !e.disabled() && (A.value = e.key, await h(), e.element.focus());
+		}
+		function V(t, n) {
+			let r = z().filter((e) => !e.disabled()), i = r.findIndex((e) => e.key === t.key);
+			if (n.key === "ArrowDown") {
+				n.preventDefault(), B(r[i + 1]);
+				return;
+			}
+			if (n.key === "ArrowUp") {
+				n.preventDefault(), B(r[i - 1]);
+				return;
+			}
+			if (n.key === "Home") {
+				n.preventDefault(), B(r[0]);
+				return;
+			}
+			if (n.key === "End") {
+				n.preventDefault(), B(e(r));
+				return;
+			}
+			if (n.key === "ArrowRight" && t.hasChildren()) {
+				n.preventDefault(), t.expanded() ? B(r.find((e) => e.parentKey === t.key)) : t.toggle();
+				return;
+			}
+			if (n.key === "ArrowLeft") {
+				n.preventDefault(), t.hasChildren() && t.expanded() ? t.toggle() : t.parentKey !== void 0 && B(j.get(t.parentKey));
+				return;
+			}
+			if (n.key === "Enter" || n.key === " ") {
+				n.preventDefault(), n.key === " " && E.selection.mode === "multiple" ? t.select() : t.activate("keyboard");
+				return;
+			}
+			n.key.length !== 1 || n.ctrlKey || n.metaKey || n.altKey || (M += n.key.toLocaleLowerCase(), N !== void 0 && clearTimeout(N), N = setTimeout(() => {
+				M = "";
+			}, 500), B([...r.slice(i + 1), ...r.slice(0, i + 1)].find((e) => E.model.label(e.node).toLocaleLowerCase().startsWith(M))));
+		}
+		function H(e) {
+			if (E.model.disabled(e)) return [];
+			let t = E.model.multipleSelection(e);
+			if (t === "disabled") return [];
+			if (t === "self") return [E.model.key(e)];
+			let n = E.model.children(e).flatMap((e) => H(e));
+			return t === "self-and-descendants" ? [E.model.key(e), ...n] : n;
+		}
+		function U(e) {
+			if (E.model.disabled(e) || E.selection.mode !== "single") return;
+			let t = E.model.key(e), n = E.selection.key === t ? null : t;
+			D("update:selection", {
+				mode: "single",
+				key: n
+			}), D("node-select", {
+				node: e,
+				key: t
+			});
+		}
+		function W(e, t) {
+			E.model.disabled(e) || E.model.children(e).length > 0 || D("node-activate", {
+				node: e,
+				key: E.model.key(e),
+				origin: t
+			});
+		}
+		function G(e) {
+			if (E.selection.mode !== "multiple") return;
+			let t = H(e);
+			if (t.length === 0) return;
+			let n = new Set(E.selection.keys), r = t.every((e) => n.has(e));
+			for (let e of t) r ? n.delete(e) : n.add(e);
+			D("update:selection", {
+				mode: "multiple",
+				keys: n
+			});
+		}
+		function K(e) {
+			let t = E.model.key(e), n = new Set(E.expanded), r = {
+				node: e,
+				key: t
+			};
+			n.has(t) ? (n.delete(t), D("node-collapse", r)) : (n.add(t), D("node-expand", r)), D("update:expanded", n);
+		}
+		let q = {
+			get model() {
+				return E.model;
+			},
+			selection: l(() => E.selection),
+			expanded: l(() => E.expanded),
+			density: l(() => E.density),
+			actionsLayout: l(() => E.actionsLayout),
+			expandControl: l(() => E.expandControl),
+			selectionRail: l(() => E.selectionRail),
+			rowVariant: l(() => E.rowVariant),
+			activeKey: A,
+			activateNode: W,
+			selectNode: U,
+			toggleNode: K,
+			checkNode: G,
+			multipleKeys: H,
+			register: L,
+			unregister: R,
+			handleItemKeydown: V
+		};
+		return _(n, q), S(I, (e) => {
+			if (A.value !== void 0) return;
+			let t = e.find((e) => !E.model.disabled(e));
+			A.value = t === void 0 ? void 0 : E.model.key(t);
+		}, { immediate: !0 }), (e, t) => (g(), d("ul", m(x(O).bindings(), {
+			ref_key: "treeRef",
+			ref: k,
+			class: ["s-tree", [
+				`s-tree--density-${E.density}`,
+				`s-tree--actions-${E.actionsLayout}`,
+				`s-tree--expand-${E.expandControl}`,
+				`s-tree--selection-rail-${E.selectionRail}`,
+				`s-tree--row-${E.rowVariant}`
+			]],
+			role: "tree",
+			"aria-label": E.label,
+			"aria-multiselectable": E.selection.mode === "multiple" || void 0
+		}), [(g(!0), d(c, null, y(I.value, (t, n) => (g(), u(o, {
+			key: E.model.key(t),
+			node: t,
+			level: 0,
+			position: n + 1,
+			"set-size": I.value.length
+		}, f({ _: 2 }, [
+			e.$slots["col-left"] ? {
+				name: "col-left",
+				fn: C((t) => [b(e.$slots, "col-left", m({ ref_for: !0 }, t))]),
+				key: "0"
+			} : void 0,
+			e.$slots["col-center"] ? {
+				name: "col-center",
+				fn: C((t) => [b(e.$slots, "col-center", m({ ref_for: !0 }, t))]),
+				key: "1"
+			} : void 0,
+			e.$slots.meta ? {
+				name: "meta",
+				fn: C((t) => [b(e.$slots, "meta", m({ ref_for: !0 }, t))]),
+				key: "2"
+			} : void 0,
+			e.$slots["persistent-actions"] ? {
+				name: "persistent-actions",
+				fn: C((t) => [b(e.$slots, "persistent-actions", m({ ref_for: !0 }, t))]),
+				key: "3"
+			} : void 0,
+			e.$slots.actions ? {
+				name: "actions",
+				fn: C((t) => [b(e.$slots, "actions", m({ ref_for: !0 }, t))]),
+				key: "4"
+			} : void 0
+		]), 1032, [
+			"node",
+			"position",
+			"set-size"
+		]))), 128))], 16, w));
+	}
+});
+//#endregion
+export { T as default };

package/dist/src/components/shared/complex/treeAdapter.d.ts

@@ -0,0 +1,16 @@
+import { SelectionKey } from '../_internal/useSelectionRoving';
+import { TreeModel } from './types';
+export interface FlatTreeAdapter<T extends object, K extends SelectionKey> {
+    key(node: T): K;
+    parentKey(node: T): K | null;
+    attachChildren(node: T, children: readonly T[]): T;
+}
+/**
+ * Строит иерархию из плоских доменных данных. / Builds a hierarchy from flat domain data.
+ *
+ * Adapter не угадывает поля, не клонирует данные spread-оператором и не
+ * исправляет orphan/cycle payload. Любое нарушение даёт координатную ошибку.
+ */
+export declare function buildTreeFromFlat<T extends object, K extends SelectionKey>(nodes: readonly T[], adapter: FlatTreeAdapter<T, K>): readonly T[];
+/** Проверяет точный runtime-контракт дерева. / Validates the exact runtime tree contract. */
+export declare function validateTreeModel<T extends object, K extends SelectionKey>(nodes: readonly T[], model: TreeModel<T, K>): ReadonlySet<K>;

package/dist/src/components/shared/complex/treeAdapter.js

@@ -0,0 +1,100 @@
+import { withErrorCause as e } from "../../../internal/es2020.js";
+import { assertSelectionKey as t, selectionKeyToken as n, validateSelectionIdentities as r } from "../_internal/useSelectionRoving.js";
+//#region src/components/shared/complex/treeAdapter.ts
+function i(e) {
+	return n("tree adapter", e, "diagnostic key");
+}
+function a(e, n) {
+	if (!Array.isArray(e)) throw TypeError("buildTreeFromFlat.nodes: expected an array");
+	let a = e.map((e, r) => {
+		let i = `buildTreeFromFlat.nodes[${r}]`, a = n.key(e);
+		return t("buildTreeFromFlat", a, `${i}.key`), {
+			node: e,
+			key: a,
+			parentKey: n.parentKey(e),
+			coordinate: i,
+			children: []
+		};
+	}), s = /* @__PURE__ */ new Map();
+	r("buildTreeFromFlat", a.map((e) => ({
+		key: e.key,
+		coordinate: `${e.coordinate}.key`
+	})));
+	for (let e of a) s.set(e.key, e);
+	for (let e of a) if (e.parentKey !== null) {
+		if (t("buildTreeFromFlat", e.parentKey, `${e.coordinate}.parentKey`), e.parentKey === e.key) throw TypeError(`${e.coordinate}: node ${i(e.key)} cannot be its own parent`);
+		if (!s.has(e.parentKey)) throw TypeError(`${e.coordinate}: parent ${i(e.parentKey)} does not exist in the flat input`);
+	}
+	for (let e of a) {
+		let t = /* @__PURE__ */ new Set([e.key]), n = e.parentKey;
+		for (; n !== null;) {
+			if (t.has(n)) throw TypeError(`${e.coordinate}: parent chain contains a cycle at ${i(n)}`);
+			t.add(n);
+			let r = s.get(n);
+			if (!r) throw TypeError(`${e.coordinate}: parent chain is incomplete at ${i(n)}`);
+			n = r.parentKey;
+		}
+	}
+	let c = [];
+	for (let e of a) {
+		if (e.parentKey === null) {
+			c.push(e.node);
+			continue;
+		}
+		let t = s.get(e.parentKey);
+		if (!t) throw TypeError(`${e.coordinate}: parent ${i(e.parentKey)} is unavailable`);
+		t.children.push(e.node);
+	}
+	return c.map((e) => {
+		let t = s.get(n.key(e));
+		if (!t) throw TypeError("buildTreeFromFlat: root is absent from the validated key index");
+		return o(t, s, n);
+	});
+}
+function o(e, t, n) {
+	let r = e.children.map((e) => {
+		let r = t.get(n.key(e));
+		if (!r) throw TypeError("buildTreeFromFlat: child is absent from the validated key index");
+		return o(r, t, n);
+	});
+	return n.attachChildren(e.node, r);
+}
+function s(t, n, r) {
+	try {
+		return r();
+	} catch (r) {
+		throw e(/* @__PURE__ */ TypeError(`STree: model.${n} failed at ${t}`), r);
+	}
+}
+function c(e, n) {
+	if (!Array.isArray(e)) throw TypeError("STree: nodes must be an array");
+	let i = [], a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), c = (e, r) => {
+		if (typeof e != "object" || !e) throw TypeError(`STree: node must be an object at ${r}`);
+		if (o.has(e)) throw TypeError(`STree: cyclic child reference at ${r}`);
+		if (a.has(e)) throw TypeError(`STree: the same node object is referenced more than once at ${r}`);
+		o.add(e), a.add(e);
+		let l = s(r, "key", () => n.key(e));
+		t("STree", l, `${r}.key`), i.push({
+			key: l,
+			coordinate: `${r}.key`
+		});
+		let u = s(r, "label", () => n.label(e));
+		if (typeof u != "string" || u.trim().length === 0) throw TypeError(`STree: model.label must return a non-empty string at ${r}`);
+		let d = s(r, "children", () => n.children(e));
+		if (!Array.isArray(d)) throw TypeError(`STree: model.children must return an array at ${r}`);
+		if (typeof s(r, "disabled", () => n.disabled(e)) != "boolean") throw TypeError(`STree: model.disabled must return a boolean at ${r}`);
+		let f = s(r, "icon", () => n.icon(e));
+		if (f !== void 0 && typeof f != "function" && (typeof f != "object" || !f)) throw TypeError(`STree: model.icon must return a Vue component or undefined at ${r}`);
+		let p = s(r, "multipleSelection", () => n.multipleSelection(e));
+		if (![
+			"self",
+			"descendants",
+			"self-and-descendants",
+			"disabled"
+		].includes(p)) throw TypeError(`STree: model.multipleSelection returned an unsupported value at ${r}`);
+		d.forEach((e, t) => c(e, `${r}.children[${t}]`)), o.delete(e);
+	};
+	return e.forEach((e, t) => c(e, `nodes[${t}]`)), r("STree", i), new Set(i.map((e) => e.key));
+}
+//#endregion
+export { a as buildTreeFromFlat, c as validateTreeModel };