@pgcorp/ui-kit 0.10.0 → 0.10.1

package/dist/src/components/shared/graph/SGraphViewport.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,513 @@
+import { useUiKitLocale as e } from "../../../composables/useUiKitLocale.js";
+import { useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { useInteractiveLeafRegistration as n } from "../../../internal/passiveContentContract.js";
+import r from "../feedback/SAsyncState.vue.js";
+import i from "../controls/SListbox.vue.js";
+import { useRuntimeTheme as a } from "../../../internal/runtimeTheme.js";
+import { SGraphContractError as o, assertSGraphViewportGraph as s, assertSGraphViewportInteraction as ee } from "./_internal/graphViewportContract.js";
+import { computed as c, createCommentVNode as te, createElementBlock as l, createElementVNode as u, createVNode as d, defineComponent as f, mergeProps as ne, nextTick as re, normalizeClass as ie, onBeforeUnmount as ae, onMounted as oe, openBlock as p, ref as m, unref as se, watch as h } from "vue";
+import ce from "graphology";
+import le from "sigma";
+//#region src/components/shared/graph/SGraphViewport.vue?vue&type=script&setup=true&lang.ts
+var g = ["data-render-state", "data-positioning"], ue = {
+	key: 0,
+	class: "s-graph-viewport__error"
+}, de = 1, _ = /*@__PURE__*/ f({
+	inheritAttrs: !1,
+	__name: "SGraphViewport",
+	props: {
+		graph: {},
+		interaction: {},
+		nodeListLabel: {},
+		nodeListEmptyLabel: {},
+		showEdgeLabels: {
+			type: Boolean,
+			default: !1
+		},
+		labelZoomThreshold: { default: .76 },
+		nodeSizeMode: { default: "screen" }
+	},
+	emits: [
+		"hover-node",
+		"leave-node",
+		"selection-change",
+		"activate-node",
+		"positions-change",
+		"render-metric",
+		"render-error"
+	],
+	setup(f, { expose: _, emit: fe }) {
+		let v = f, y = fe, pe = t({
+			component: "SGraphViewport",
+			owner: "graph viewport root"
+		}), { t: b } = e();
+		n({ owner: "SGraphViewport" });
+		let x = m(null), me = a(), S = m("idle"), C = m(null), w = null, T = null, E = null, D = null, O = null, k = /* @__PURE__ */ new Map(), A = !1;
+		function j() {
+			if (s(v.graph), ee(v.interaction, v.graph), typeof v.nodeListLabel != "string" || v.nodeListLabel.trim().length === 0) throw new o("SGraphViewport: nodeListLabel должен быть непустой строкой.");
+			if (typeof v.nodeListEmptyLabel != "string" || v.nodeListEmptyLabel.trim().length === 0) throw new o("SGraphViewport: nodeListEmptyLabel должен быть непустой строкой.");
+			if (!Number.isFinite(v.labelZoomThreshold) || v.labelZoomThreshold <= 0) throw new o("SGraphViewport: labelZoomThreshold должен быть конечным числом больше 0.");
+			if (!["screen", "graph"].includes(v.nodeSizeMode)) throw new o(`SGraphViewport: неизвестный nodeSizeMode "${String(v.nodeSizeMode)}".`);
+			if (typeof v.showEdgeLabels != "boolean") throw new o("SGraphViewport: showEdgeLabels должен быть boolean.");
+		}
+		let M = c(() => (j(), v.interaction)), he = c(() => (j(), v.nodeListLabel)), ge = c(() => (j(), v.nodeListEmptyLabel)), N = c(() => M.value.positioning.mode), P = c(() => M.value.selection.mode === "single" ? M.value.selection.nodeId : null), _e = c(() => new Set(P.value === null ? [] : [P.value])), ve = c(() => (j(), v.graph.nodes.map((e) => ({
+			value: e.id,
+			label: e.label
+		}))));
+		function F(e) {
+			let t = x.value;
+			if (!t) throw Error(`SGraphViewport: невозможно прочитать semantic token ${e} до монтирования viewport.`);
+			let n = getComputedStyle(t).getPropertyValue(e).trim();
+			if (!n) throw Error(`SGraphViewport: обязательный semantic token ${e} отсутствует в computed style.`);
+			return n;
+		}
+		function ye(e) {
+			let t = F(e), n = Number(t);
+			if (!Number.isFinite(n)) throw Error(`SGraphViewport: semantic token ${e} должен быть конечным unitless number, получено '${t}'.`);
+			return n;
+		}
+		function I(e) {
+			let t = F(e), n = t.match(/^(-?(?:\d+(?:\.\d+)?|\.\d+))px$/u);
+			if (!n) throw Error(`SGraphViewport: semantic token ${e} должен быть вычислен в px, получено '${t}'.`);
+			return Number(n[1]);
+		}
+		function L(e) {
+			let t = F(e), n = t.match(/^((?:\d+(?:\.\d+)?|\.\d+))(ms|s)$/u);
+			if (!n) throw Error(`SGraphViewport: semantic token ${e} должен быть вычислен в ms или s, получено '${t}'.`);
+			let r = Number(n[1]);
+			return n[2] === "s" ? r * 1e3 : r;
+		}
+		function R(e) {
+			let t = F(e);
+			if (!/^#[\da-f]{6}$/iu.test(t)) throw Error(`SGraphViewport: semantic token ${e} должен быть вычислен в #RRGGBB, получено '${t}'.`);
+			return t;
+		}
+		function z(e) {
+			return {
+				color: R(`--s-graph-node-tone-${e}-fill`),
+				borderColor: R(`--s-graph-node-tone-${e}-border`),
+				labelColor: R(`--s-graph-node-tone-${e}-label`)
+			};
+		}
+		function B(e) {
+			return R(`--s-graph-edge-tone-${e}`);
+		}
+		function be(e, t) {
+			return t === void 0 || t === 1 ? e : `rgba(${Number.parseInt(e.slice(1, 3), 16)}, ${Number.parseInt(e.slice(3, 5), 16)}, ${Number.parseInt(e.slice(5, 7), 16)}, ${t})`;
+		}
+		function V(e) {
+			s(e);
+			let t = new ce({
+				multi: !0,
+				type: "mixed"
+			});
+			for (let n of e.nodes) t.addNode(n.id, {
+				...n,
+				...z(n.tone),
+				highlighted: !1,
+				hidden: !1
+			});
+			for (let n of e.edges) t.addEdgeWithKey(n.id, n.source, n.target, {
+				...n,
+				color: B(n.tone),
+				hidden: n.hidden ?? !1,
+				size: n.size ?? 1,
+				opacity: n.opacity ?? 1
+			});
+			return t;
+		}
+		function xe() {
+			if (T) {
+				for (let e of v.graph.nodes) {
+					if (!T.hasNode(e.id)) throw Error(`SGraphViewport: node "${e.id}" отсутствует при обновлении runtime theme.`);
+					let t = z(e.tone);
+					T.setNodeAttribute(e.id, "color", t.color), T.setNodeAttribute(e.id, "borderColor", t.borderColor), T.setNodeAttribute(e.id, "labelColor", t.labelColor);
+				}
+				for (let e of v.graph.edges) {
+					if (!T.hasEdge(e.id)) throw Error(`SGraphViewport: edge "${e.id}" отсутствует при обновлении runtime theme.`);
+					T.setEdgeAttribute(e.id, "color", B(e.tone));
+				}
+			}
+		}
+		function H() {
+			return {
+				renderLabels: !0,
+				renderEdgeLabels: v.showEdgeLabels,
+				hideEdgesOnMove: !0,
+				hideLabelsOnMove: !0,
+				enableEdgeEvents: !1,
+				defaultNodeColor: R("--s-graph-node-default-color"),
+				defaultEdgeColor: R("--s-graph-edge-default-color"),
+				labelColor: {
+					attribute: "labelColor",
+					color: R("--s-graph-label-color")
+				},
+				labelFont: F("--s-graph-label-font-family"),
+				labelSize: I("--s-graph-label-font-size"),
+				labelWeight: F("--s-graph-label-font-weight"),
+				labelDensity: ye("--s-graph-label-density"),
+				labelGridCellSize: I("--s-graph-label-grid-cell-size"),
+				labelRenderedSizeThreshold: I("--s-graph-label-rendered-size-threshold"),
+				minEdgeThickness: I("--s-graph-min-edge-thickness"),
+				stagePadding: I("--s-graph-stage-padding"),
+				zIndex: !0,
+				...v.nodeSizeMode === "screen" ? { zoomToSizeRatioFunction: (e) => Math.max(.08, Math.min(.72, Math.sqrt(Math.max(1e-4, e)) * .78)) } : {},
+				nodeReducer: (e, t) => {
+					let n = _e.value.has(e), r = !!t.forceLabel || n || t.highlighted, i = w?.getCamera().getState().ratio ?? de, a = r || i < v.labelZoomThreshold ? t.label : "";
+					return {
+						x: t.x,
+						y: t.y,
+						label: a,
+						color: n ? t.borderColor : t.color,
+						size: n ? Math.min(t.size * 1.16, t.size + 1.4) : t.size,
+						forceLabel: r,
+						highlighted: t.highlighted || n,
+						zIndex: t.role === "group" || t.role === "coverage" ? 4 : n ? 5 : 1
+					};
+				},
+				edgeReducer: (e, t) => {
+					if (!T) throw Error("SGraphViewport: edge reducer вызван без rendered graph.");
+					if (!T.hasNode(t.source) || !T.hasNode(t.target)) throw Error(`SGraphViewport: edge "${t.id}" ссылается на отсутствующий rendered node при reducer.`);
+					let n = P.value, r = n ? t.source === n || t.target === n : !1, i = !!T.getNodeAttribute(t.source, "highlighted"), a = !!T.getNodeAttribute(t.target, "highlighted"), o = r || i || a;
+					return {
+						color: be(t.color, o ? Math.max(t.opacity, .55) : t.opacity),
+						size: o ? Math.max(t.size, 1.4) : t.size,
+						hidden: t.hidden || !(!n || r) || !(!t.showOnInteractionOnly || o),
+						forceLabel: !1
+					};
+				}
+			};
+		}
+		function U(e, t) {
+			y("render-metric", {
+				phase: e,
+				durationMs: performance.now() - t,
+				nodes: v.graph.nodes.length,
+				edges: v.graph.edges.length,
+				renderer: "sigma"
+			});
+		}
+		function W(e, t) {
+			w?.kill(), w = null, T = null, S.value = "failed", C.value = {
+				reason: e,
+				message: t,
+				nodes: v.graph.nodes.length,
+				edges: v.graph.edges.length
+			}, y("render-error", C.value);
+		}
+		function G() {
+			C.value = null, S.value === "failed" && (S.value = "idle");
+		}
+		function K() {
+			let e = x.value;
+			return e ? e.clientWidth > 0 && e.clientHeight > 0 : !1;
+		}
+		function Se() {
+			return document.createElement("canvas").getContext("webgl2") !== null;
+		}
+		function q() {
+			!w && K() && we();
+		}
+		function Ce() {
+			if (w) try {
+				xe(), w.setSettings(H()), w.refresh();
+			} catch (e) {
+				W("sigma_mount_failed", e instanceof Error ? e.message : b("graph.themeFailed"));
+			}
+		}
+		function we() {
+			let e = x.value;
+			if (!e || !K()) return;
+			let t;
+			try {
+				j(), t = V(v.graph);
+			} catch (e) {
+				W(e instanceof o ? "invalid_graph" : "sigma_mount_failed", e instanceof Error ? e.message : b("graph.invalidData"));
+				return;
+			}
+			if (!Se()) {
+				W("webgl_unavailable", b("graph.webglRequired"));
+				return;
+			}
+			let n = performance.now();
+			try {
+				T = t, w = new le(T, e, H()), G(), S.value = "painted", Te(), U("sigma_mount", n);
+			} catch (e) {
+				W(e instanceof o ? "invalid_graph" : "sigma_mount_failed", e instanceof Error ? e.message : b("graph.renderFailed"));
+			}
+		}
+		function J(e, t) {
+			if (!T?.hasNode(e)) throw Error(`SGraphViewport: node "${e}" отсутствует при ${t}.`);
+		}
+		function Y(e) {
+			if (e.mode === "single" && !v.graph.nodes.some((t) => t.id === e.nodeId)) throw new o(`SGraphViewport: selection-change ссылается на отсутствующий node "${e.nodeId}".`);
+			y("selection-change", e);
+		}
+		function X(e) {
+			if (!v.graph.nodes.some((t) => t.id === e)) throw new o(`SGraphViewport: activate-node ссылается на отсутствующий node "${e}".`);
+			y("activate-node", e);
+		}
+		function Te() {
+			if (!w || !T) throw Error("SGraphViewport: Sigma event binding требует mounted renderer и graph.");
+			w.on("enterNode", ({ node: e, event: t }) => {
+				J(e, "hover"), T?.setNodeAttribute(e, "highlighted", !0), w?.refresh(), y("hover-node", {
+					nodeId: e,
+					pointer: {
+						x: t.x,
+						y: t.y
+					}
+				});
+			}), w.on("leaveNode", ({ node: e }) => {
+				J(e, "leave"), T?.setNodeAttribute(e, "highlighted", !1), w?.refresh(), y("leave-node");
+			}), w.on("clickNode", ({ node: e }) => {
+				A || Y({
+					mode: "single",
+					nodeId: e
+				});
+			}), w.on("clickStage", () => {
+				A || Y({ mode: "none" });
+			}), w.on("doubleClickNode", ({ node: e }) => X(e)), w.on("downNode", ({ node: e }) => Oe(e)), w.getMouseCaptor().on("mousemovebody", ke), w.getMouseCaptor().on("mouseup", Ae), w.getMouseCaptor().on("mousedown", () => {
+				w?.getCustomBBox() || w?.setCustomBBox(w.getBBox());
+			});
+		}
+		function Ee() {
+			let e = performance.now(), t;
+			try {
+				j(), t = V(v.graph);
+			} catch (e) {
+				W("invalid_graph", e instanceof Error ? e.message : b("graph.invalidData"));
+				return;
+			}
+			try {
+				if (T = t, w) {
+					w.setGraph(t), w.setSettings(H()), w.refresh(), G(), S.value = "painted", U("graph_replace", e);
+					return;
+				}
+				q();
+			} catch (e) {
+				W(e instanceof o ? "invalid_graph" : "sigma_mount_failed", e instanceof Error ? e.message : b("graph.renderFailed"));
+			}
+		}
+		function De() {
+			try {
+				j();
+			} catch (e) {
+				W("invalid_graph", e instanceof Error ? e.message : b("graph.invalidData"));
+				return;
+			}
+			if (N.value === "readonly" && $(), !w) {
+				q();
+				return;
+			}
+			w.refresh();
+		}
+		function Z() {
+			try {
+				j();
+			} catch (e) {
+				W("invalid_graph", e instanceof Error ? e.message : b("graph.invalidData"));
+				return;
+			}
+			if (!w) {
+				q();
+				return;
+			}
+			try {
+				w.setSettings(H()), w.refresh();
+			} catch (e) {
+				W("sigma_mount_failed", e instanceof Error ? e.message : b("graph.renderFailed"));
+			}
+		}
+		function Q() {
+			return M.value.positioning.mode === "editable";
+		}
+		function Oe(e) {
+			if (!Q()) return;
+			if (!w || !T) throw Error("SGraphViewport: pointer positioning требует mounted renderer и graph.");
+			J(e, "начале drag"), D = e, O = {
+				x: Number(T.getNodeAttribute(e, "x")),
+				y: Number(T.getNodeAttribute(e, "y"))
+			};
+			let t = T.getNodeAttribute(e, "dragGroupIds") ?? [];
+			k = /* @__PURE__ */ new Map();
+			for (let n of [e, ...t]) J(n, "начале group drag"), k.set(n, {
+				x: Number(T.getNodeAttribute(n, "x")),
+				y: Number(T.getNodeAttribute(n, "y"))
+			});
+			T.setNodeAttribute(e, "highlighted", !0), A = !1;
+		}
+		function ke(e) {
+			if (!D) return;
+			if (!Q()) {
+				$();
+				return;
+			}
+			if (!w || !T || !O) throw Error("SGraphViewport: active drag потерял renderer, graph или start position.");
+			let t = w.viewportToGraph(e), n = {
+				x: t.x - O.x,
+				y: t.y - O.y
+			};
+			Math.abs(n.x) + Math.abs(n.y) > .5 && (A = !0);
+			for (let [e, t] of k.entries()) J(e, "обновлении drag"), T.setNodeAttribute(e, "x", t.x + n.x), T.setNodeAttribute(e, "y", t.y + n.y);
+			e.preventSigmaDefault(), e.original.preventDefault();
+		}
+		function Ae() {
+			if (!D) {
+				A = !1;
+				return;
+			}
+			if (!Q()) {
+				$();
+				return;
+			}
+			if (!T) throw Error("SGraphViewport: active drag потерял rendered graph при завершении.");
+			J(D, "завершении drag"), T.setNodeAttribute(D, "highlighted", !1);
+			let e = [];
+			for (let t of k.keys()) J(t, "завершении group drag"), e.push({
+				nodeId: t,
+				position: {
+					x: Number(T.getNodeAttribute(t, "x")),
+					y: Number(T.getNodeAttribute(t, "y"))
+				}
+			});
+			A && y("positions-change", e), D = null, O = null, k = /* @__PURE__ */ new Map(), window.setTimeout(() => {
+				A = !1;
+			}, 0);
+		}
+		function $() {
+			T && D && T.hasNode(D) && T.setNodeAttribute(D, "highlighted", !1), D = null, O = null, k = /* @__PURE__ */ new Map(), A = !1;
+		}
+		function je(e) {
+			if (typeof e != "string" || e.trim().length === 0) throw new o("SGraphViewport: SListbox вернул недопустимый node id.");
+			Y({
+				mode: "single",
+				nodeId: e
+			});
+		}
+		function Me(e) {
+			if (T?.hasNode(e)) return {
+				x: Number(T.getNodeAttribute(e, "x")),
+				y: Number(T.getNodeAttribute(e, "y"))
+			};
+			let t = v.graph.nodes.find((t) => t.id === e);
+			if (!t) throw Error(`SGraphViewport: node "${e}" отсутствует при keyboard positioning.`);
+			return {
+				x: t.x,
+				y: t.y
+			};
+		}
+		function Ne(e, t) {
+			let n = v.graph.nodes.find((t) => t.id === e);
+			if (!n) throw Error(`SGraphViewport: node "${e}" отсутствует при keyboard positioning.`);
+			let r = [n.id, ...n.dragGroupIds ?? []].map((e) => {
+				let n = Me(e), r = {
+					x: n.x + t.x,
+					y: n.y + t.y
+				};
+				return T?.hasNode(e) && (T.setNodeAttribute(e, "x", r.x), T.setNodeAttribute(e, "y", r.y)), {
+					nodeId: e,
+					position: r
+				};
+			});
+			w?.refresh(), Y({
+				mode: "single",
+				nodeId: e
+			}), y("positions-change", r);
+		}
+		function Pe(e) {
+			let { event: t, value: n } = e;
+			if (n === null) throw new o("SGraphViewport: node inventory не поддерживает clear option.");
+			if (t.key === "Enter" && !t.altKey && !t.ctrlKey && !t.metaKey && !t.shiftKey) {
+				X(n);
+				return;
+			}
+			let r = M.value.positioning;
+			if (r.mode !== "editable" || !t.altKey || t.ctrlKey || t.metaKey || t.shiftKey) return;
+			let i = r.keyboardStep, a = {
+				ArrowLeft: {
+					x: -i,
+					y: 0
+				},
+				ArrowRight: {
+					x: i,
+					y: 0
+				},
+				ArrowUp: {
+					x: 0,
+					y: -i
+				},
+				ArrowDown: {
+					x: 0,
+					y: i
+				}
+			}[t.key];
+			a && (t.preventDefault(), t.stopPropagation(), Ne(n, a));
+		}
+		oe(() => {
+			j();
+			let e = x.value;
+			typeof ResizeObserver < "u" && e && (E = new ResizeObserver(() => {
+				if (!w) {
+					q();
+					return;
+				}
+				w.resize(), w.refresh();
+			}), E.observe(e)), re(q);
+		}), ae(() => {
+			E?.disconnect(), E = null, w?.kill(), w = null, T = null, C.value = null, S.value = "idle", $();
+		}), h(() => v.graph, Ee, { deep: !0 }), h(me, Ce), h(() => v.interaction, De, { deep: !0 }), h(() => v.showEdgeLabels, Z), h(() => v.labelZoomThreshold, Z), h(() => v.nodeSizeMode, Z);
+		function Fe() {
+			let e = w?.getCamera();
+			if (!e) return;
+			let t = e.getState();
+			e.animate({ ratio: Math.max(t.ratio * .82, .02) }, { duration: L("--s-graph-camera-duration") });
+		}
+		function Ie() {
+			let e = w?.getCamera();
+			if (!e) return;
+			let t = e.getState();
+			e.animate({ ratio: Math.min(t.ratio * 1.18, 12) }, { duration: L("--s-graph-camera-duration") });
+		}
+		function Le() {
+			w?.setCustomBBox(null), w?.getCamera().animatedReset({ duration: L("--s-graph-camera-reset-duration") });
+		}
+		return _({
+			zoomIn: Fe,
+			zoomOut: Ie,
+			fit: Le
+		}), (e, t) => (p(), l("div", ne(se(pe).bindings(), {
+			class: "s-graph-viewport",
+			"data-render-state": S.value,
+			"data-positioning": N.value
+		}), [
+			u("div", {
+				ref_key: "rendererRef",
+				ref: x,
+				class: "s-graph-viewport__renderer",
+				"aria-hidden": "true"
+			}, null, 512),
+			C.value ? (p(), l("div", ue, [d(r, {
+				state: {
+					status: "error",
+					message: C.value.message
+				},
+				presentation: "block"
+			}, null, 8, ["state"])])) : te("", !0),
+			u("div", { class: ie(["s-graph-viewport__node-inventory", { "s-graph-viewport__node-inventory--fallback": C.value !== null }]) }, [d(i, {
+				label: he.value,
+				"model-value": P.value,
+				options: ve.value,
+				"empty-label": ge.value,
+				"onUpdate:modelValue": je,
+				onOptionKeydown: Pe
+			}, null, 8, [
+				"label",
+				"model-value",
+				"options",
+				"empty-label"
+			])], 2)
+		], 16, g));
+	}
+});
+//#endregion
+export { _ as default };

package/dist/src/components/shared/graph/_internal/graphViewportContract.d.ts

@@ -0,0 +1,114 @@
+/** Поддерживаемые семантические тона графа. / Supported semantic graph tones. */
+export declare const S_GRAPH_TONES: readonly ["neutral", "primary", "info", "success", "warning", "danger", "accent"];
+/** Семантический тон, разрешаемый UI-kit в theme tokens. / Theme-token-resolved semantic tone. */
+export type SGraphTone = (typeof S_GRAPH_TONES)[number];
+/** Семантическая роль узла в раскладке. / Semantic node role in the layout. */
+export type SGraphNodeRole = 'item' | 'group' | 'coverage' | 'relation';
+/** Точная позиция узла в координатах графа. / Exact position in graph coordinates. */
+export interface SGraphPosition {
+    x: number;
+    y: number;
+}
+/** Публичные данные узла без presentation colors. / Public node data without presentation colors. */
+export interface SGraphNode {
+    id: string;
+    label: string;
+    role: SGraphNodeRole;
+    kind: string;
+    group?: string | null;
+    tone: SGraphTone;
+    size: number;
+    x: number;
+    y: number;
+    count?: number | null;
+    forceLabel?: boolean;
+    dragGroupIds?: readonly string[];
+    payload?: Record<string, unknown> | null;
+}
+/** Публичные данные ребра без presentation colors. / Public edge data without presentation colors. */
+export interface SGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    relationType: string;
+    tone: SGraphTone;
+    size?: number;
+    opacity?: number;
+    hidden?: boolean;
+    showOnInteractionOnly?: boolean;
+    payload?: Record<string, unknown> | null;
+}
+/** Полный immutable input графа. / Complete immutable graph input. */
+export interface SGraphViewportGraph {
+    nodes: readonly SGraphNode[];
+    edges: readonly SGraphEdge[];
+}
+/** Controlled отсутствие или один выбранный узел. / Controlled none-or-single node selection. */
+export type SGraphSelection = {
+    mode: 'none';
+} | {
+    mode: 'single';
+    nodeId: string;
+};
+/** Readonly или editable позиционирование с точным keyboard step. / Readonly or editable positioning with an exact keyboard step. */
+export type SGraphPositioning = {
+    mode: 'readonly';
+} | {
+    mode: 'editable';
+    keyboardStep: number;
+};
+/** Единый controlled interaction-контракт viewport. / Unified controlled viewport interaction contract. */
+export interface SGraphViewportInteraction {
+    selection: SGraphSelection;
+    positioning: SGraphPositioning;
+}
+/** Ошибка точного runtime-контракта графа. / Exact graph runtime contract error. */
+export declare class SGraphContractError extends TypeError {
+    readonly name = "SGraphContractError";
+}
+/**
+ * Проверяет точный граф до передачи в Graphology/Sigma без silent skip, clamp или merge.
+ * Validates the exact graph before Graphology/Sigma without silent skips, clamps, or merges.
+ */
+export declare function assertSGraphViewportGraph(value: unknown): asserts value is SGraphViewportGraph;
+/**
+ * Проверяет controlled selection и positioning как один exact interaction-контракт.
+ * Validates controlled selection and positioning as one exact interaction contract.
+ */
+export declare function assertSGraphViewportInteraction(value: unknown, graph: SGraphViewportGraph): asserts value is SGraphViewportInteraction;
+/** Режим масштабирования размеров узлов Sigma. / Sigma node-size scaling mode. */
+export type SGraphNodeSizeMode = 'screen' | 'graph';
+/** Измеряемая фаза renderer lifecycle. / Measured renderer lifecycle phase. */
+export type SGraphRenderMetricPhase = 'sigma_mount' | 'graph_replace';
+/** Метрика завершённой renderer-фазы. / Completed renderer-phase metric. */
+export interface SGraphRenderMetric {
+    phase: SGraphRenderMetricPhase;
+    durationMs: number;
+    nodes: number;
+    edges: number;
+    renderer: 'sigma';
+}
+/** Машиночитаемая причина отказа renderer. / Machine-readable renderer failure reason. */
+export type SGraphRenderErrorReason = 'webgl_unavailable' | 'invalid_graph' | 'sigma_mount_failed';
+/** Диагностируемый отказ renderer с размером входа. / Diagnosable renderer failure with input size. */
+export interface SGraphRenderError {
+    reason: SGraphRenderErrorReason;
+    message: string;
+    nodes: number;
+    edges: number;
+}
+/** Координаты pointer относительно viewport. / Pointer coordinates relative to the viewport. */
+export interface SGraphNodePointer {
+    x: number;
+    y: number;
+}
+/** Hover-событие узла с pointer coordinates. / Node hover event with pointer coordinates. */
+export interface SGraphNodePointerEvent {
+    nodeId: string;
+    pointer: SGraphNodePointer;
+}
+/** Controlled изменение позиции одного узла. / Controlled position change for one node. */
+export interface SGraphPositionChange {
+    nodeId: string;
+    position: SGraphPosition;
+}