@blueking/ai-blueking 2.0.0-dev.1 → 2.0.0-dev.3

package/dist/vue3/dagre-6UL2VRFP-CTl_U96l.js

@@ -0,0 +1,298 @@
+import "./purify.es-Cm_tUMzZ.js";
+import "./reduce-BFKSG9Rs.js";
+import "./_baseFor-DAbrc8SN.js";
+import "./isEmpty-z27q3o-D.js";
+import { a as map_default } from "./flatten-CfPhNHUL.js";
+import { g as log, h as __name } from "./src-VlKYSsxJ.js";
+import { b as getConfig2 } from "./chunk-ABZYJK2D-gsx40GnJ.js";
+import "./path-CW_-_Ti7.js";
+import "./math-DF_v6dOl.js";
+import "./array-TB8zN_HT.js";
+import "./chunk-S3R3BYOJ-Bs_r55Kk.js";
+import "./line-wvheYP7S.js";
+import "./dist-xWJvauxf.js";
+import "./chunk-JA3XYJ7Z-CRet4f6a.js";
+import "./chunk-HN2XXSSU-DueSY85P.js";
+import { t as getSubGraphTitleMargins } from "./chunk-CVBHYZKI-Cs8lCw3u.js";
+import { n as isUndefined_default, t as Graph } from "./graphlib-KDKEjVHX.js";
+import { t as clone_default } from "./clone-Bbr3WSpg.js";
+import { t as layout } from "./dagre-DUjlMe_B.js";
+import "./chunk-ATLVNIR6-CTTwtx-5.js";
+import { a as insertNode, c as positionNode, i as insertCluster, l as setNodeElem, n as clear2, t as clear$1, u as updateNodeBounds } from "./chunk-JZLCHNYA-Df0-MseJ.js";
+import { a as positionEdgeLabel, i as markers_default, n as insertEdge, r as insertEdgeLabel, t as clear } from "./chunk-QXUST7PY-DxFRymyS.js";
+function write(r) {
+	var C = {
+		options: {
+			directed: r.isDirected(),
+			multigraph: r.isMultigraph(),
+			compound: r.isCompound()
+		},
+		nodes: writeNodes(r),
+		edges: writeEdges(r)
+	};
+	return isUndefined_default(r.graph()) || (C.value = clone_default(r.graph())), C;
+}
+function writeNodes(C) {
+	return map_default(C.nodes(), function(r) {
+		var w = C.node(r), T = C.parent(r), E = { v: r };
+		return isUndefined_default(w) || (E.value = w), isUndefined_default(T) || (E.parent = T), E;
+	});
+}
+function writeEdges(C) {
+	return map_default(C.edges(), function(r) {
+		var w = C.edge(r), T = {
+			v: r.v,
+			w: r.w
+		};
+		return isUndefined_default(r.name) || (T.name = r.name), isUndefined_default(w) || (T.value = w), T;
+	});
+}
+var clusterDb = /* @__PURE__ */ new Map(), descendants = /* @__PURE__ */ new Map(), parents = /* @__PURE__ */ new Map(), clear4 = /* @__PURE__ */ __name(() => {
+	descendants.clear(), parents.clear(), clusterDb.clear();
+}, "clear"), isDescendant = /* @__PURE__ */ __name((r, w) => {
+	let T = descendants.get(w) || [];
+	return log.trace("In isDescendant", w, " ", r, " = ", T.includes(r)), T.includes(r);
+}, "isDescendant"), edgeInCluster = /* @__PURE__ */ __name((r, w) => {
+	let T = descendants.get(w) || [];
+	return log.info("Descendants of ", w, " is ", T), log.info("Edge is ", r), r.v === w || r.w === w ? !1 : T ? T.includes(r.v) || isDescendant(r.v, w) || isDescendant(r.w, w) || T.includes(r.w) : (log.debug("Tilt, ", w, ",not in descendants"), !1);
+}, "edgeInCluster"), copy = /* @__PURE__ */ __name((r, w, T, E) => {
+	log.warn("Copying children of ", r, "root", E, "data", w.node(r), E);
+	let D = w.children(r) || [];
+	r !== E && D.push(r), log.warn("Copying (nodes) clusterId", r, "nodes", D), D.forEach((D) => {
+		if (w.children(D).length > 0) copy(D, w, T, E);
+		else {
+			let O = w.node(D);
+			log.info("cp ", D, " to ", E, " with parent ", r), T.setNode(D, O), E !== w.parent(D) && (log.warn("Setting parent", D, w.parent(D)), T.setParent(D, w.parent(D))), r !== E && D !== r ? (log.debug("Setting parent", D, r), T.setParent(D, r)) : (log.info("In copy ", r, "root", E, "data", w.node(r), E), log.debug("Not Setting parent for node=", D, "cluster!==rootId", r !== E, "node!==clusterId", D !== r));
+			let k = w.edges(D);
+			log.debug("Copying Edges", k), k.forEach((D) => {
+				log.info("Edge", D);
+				let O = w.edge(D.v, D.w, D.name);
+				log.info("Edge data", O, E);
+				try {
+					edgeInCluster(D, E) ? (log.info("Copying as ", D.v, D.w, O, D.name), T.setEdge(D.v, D.w, O, D.name), log.info("newGraph edges ", T.edges(), T.edge(T.edges()[0]))) : log.info("Skipping copy of edge ", D.v, "-->", D.w, " rootId: ", E, " clusterId:", r);
+				} catch (r) {
+					log.error(r);
+				}
+			});
+		}
+		log.debug("Removing node", D), w.removeNode(D);
+	});
+}, "copy"), extractDescendants = /* @__PURE__ */ __name((r, C) => {
+	let w = C.children(r), T = [...w];
+	for (let E of w) parents.set(E, r), T = [...T, ...extractDescendants(E, C)];
+	return T;
+}, "extractDescendants"), findCommonEdges = /* @__PURE__ */ __name((r, C, w) => {
+	let T = r.edges().filter((r) => r.v === C || r.w === C), E = r.edges().filter((r) => r.v === w || r.w === w), D = T.map((r) => ({
+		v: r.v === C ? w : r.v,
+		w: r.w === C ? C : r.w
+	})), O = E.map((r) => ({
+		v: r.v,
+		w: r.w
+	}));
+	return D.filter((r) => O.some((C) => r.v === C.v && r.w === C.w));
+}, "findCommonEdges"), findNonClusterChild = /* @__PURE__ */ __name((r, w, T) => {
+	let E = w.children(r);
+	if (log.trace("Searching children of id ", r, E), E.length < 1) return r;
+	let D;
+	for (let r of E) {
+		let C = findNonClusterChild(r, w, T), E = findCommonEdges(w, T, C);
+		if (C) if (E.length > 0) D = C;
+		else return C;
+	}
+	return D;
+}, "findNonClusterChild"), getAnchorId = /* @__PURE__ */ __name((r) => !clusterDb.has(r) || !clusterDb.get(r).externalConnections ? r : clusterDb.has(r) ? clusterDb.get(r).id : r, "getAnchorId"), adjustClustersAndEdges = /* @__PURE__ */ __name((r, w) => {
+	if (!r || w > 10) {
+		log.debug("Opting out, no graph ");
+		return;
+	} else log.debug("Opting in, graph ");
+	r.nodes().forEach(function(w) {
+		r.children(w).length > 0 && (log.warn("Cluster identified", w, " Replacement id in edges: ", findNonClusterChild(w, r, w)), descendants.set(w, extractDescendants(w, r)), clusterDb.set(w, {
+			id: findNonClusterChild(w, r, w),
+			clusterData: r.node(w)
+		}));
+	}), r.nodes().forEach(function(w) {
+		let T = r.children(w), E = r.edges();
+		T.length > 0 ? (log.debug("Cluster identified", w, descendants), E.forEach((r) => {
+			isDescendant(r.v, w) ^ isDescendant(r.w, w) && (log.warn("Edge: ", r, " leaves cluster ", w), log.warn("Descendants of XXX ", w, ": ", descendants.get(w)), clusterDb.get(w).externalConnections = !0);
+		})) : log.debug("Not a cluster ", w, descendants);
+	});
+	for (let C of clusterDb.keys()) {
+		let w = clusterDb.get(C).id, T = r.parent(w);
+		T !== C && clusterDb.has(T) && !clusterDb.get(T).externalConnections && (clusterDb.get(C).id = T);
+	}
+	r.edges().forEach(function(w) {
+		let T = r.edge(w);
+		log.warn("Edge " + w.v + " -> " + w.w + ": " + JSON.stringify(w)), log.warn("Edge " + w.v + " -> " + w.w + ": " + JSON.stringify(r.edge(w)));
+		let E = w.v, D = w.w;
+		if (log.warn("Fix XXX", clusterDb, "ids:", w.v, w.w, "Translating: ", clusterDb.get(w.v), " --- ", clusterDb.get(w.w)), clusterDb.get(w.v) || clusterDb.get(w.w)) {
+			if (log.warn("Fixing and trying - removing XXX", w.v, w.w, w.name), E = getAnchorId(w.v), D = getAnchorId(w.w), r.removeEdge(w.v, w.w, w.name), E !== w.v) {
+				let C = r.parent(E);
+				clusterDb.get(C).externalConnections = !0, T.fromCluster = w.v;
+			}
+			if (D !== w.w) {
+				let C = r.parent(D);
+				clusterDb.get(C).externalConnections = !0, T.toCluster = w.w;
+			}
+			log.warn("Fix Replacing with XXX", E, D, w.name), r.setEdge(E, D, T, w.name);
+		}
+	}), log.warn("Adjusted Graph", write(r)), extractor(r, 0), log.trace(clusterDb);
+}, "adjustClustersAndEdges"), extractor = /* @__PURE__ */ __name((r, w) => {
+	if (log.warn("extractor - ", w, write(r), r.children("D")), w > 10) {
+		log.error("Bailing out");
+		return;
+	}
+	let T = r.nodes(), E = !1;
+	for (let C of T) {
+		let w = r.children(C);
+		E ||= w.length > 0;
+	}
+	if (!E) {
+		log.debug("Done, no node has children", r.nodes());
+		return;
+	}
+	log.debug("Nodes = ", T, w);
+	for (let E of T) if (log.debug("Extracting node", E, clusterDb, clusterDb.has(E) && !clusterDb.get(E).externalConnections, !r.parent(E), r.node(E), r.children("D"), " Depth ", w), !clusterDb.has(E)) log.debug("Not a cluster", E, w);
+	else if (!clusterDb.get(E).externalConnections && r.children(E) && r.children(E).length > 0) {
+		log.warn("Cluster without external connections, without a parent and with children", E, w);
+		let T = r.graph().rankdir === "TB" ? "LR" : "TB";
+		clusterDb.get(E)?.clusterData?.dir && (T = clusterDb.get(E).clusterData.dir, log.warn("Fixing dir", clusterDb.get(E).clusterData.dir, T));
+		let D = new Graph({
+			multigraph: !0,
+			compound: !0
+		}).setGraph({
+			rankdir: T,
+			nodesep: 50,
+			ranksep: 50,
+			marginx: 8,
+			marginy: 8
+		}).setDefaultEdgeLabel(function() {
+			return {};
+		});
+		log.warn("Old graph before copy", write(r)), copy(E, r, D, E), r.setNode(E, {
+			clusterNode: !0,
+			id: E,
+			clusterData: clusterDb.get(E).clusterData,
+			label: clusterDb.get(E).label,
+			graph: D
+		}), log.warn("New graph after copy node: (", E, ")", write(D)), log.debug("Old graph after copy", write(r));
+	} else log.warn("Cluster ** ", E, " **not meeting the criteria !externalConnections:", !clusterDb.get(E).externalConnections, " no parent: ", !r.parent(E), " children ", r.children(E) && r.children(E).length > 0, r.children("D"), w), log.debug(clusterDb);
+	T = r.nodes(), log.warn("New list of nodes", T);
+	for (let E of T) {
+		let T = r.node(E);
+		log.warn(" Now next level", E, T), T?.clusterNode && extractor(T.graph, w + 1);
+	}
+}, "extractor"), sorter = /* @__PURE__ */ __name((r, C) => {
+	if (C.length === 0) return [];
+	let w = Object.assign([], C);
+	return C.forEach((C) => {
+		let T = sorter(r, r.children(C));
+		w = [...w, ...T];
+	}), w;
+}, "sorter"), sortNodesByHierarchy = /* @__PURE__ */ __name((r) => sorter(r, r.children()), "sortNodesByHierarchy"), recursiveRender = /* @__PURE__ */ __name(async (r, T, D, O, k, M) => {
+	log.warn("Graph in recursive render:XAX", write(T), k);
+	let N = T.graph().rankdir;
+	log.trace("Dir in recursive render - dir:", N);
+	let P = r.insert("g").attr("class", "root");
+	T.nodes() ? log.info("Recursive render XXX", T.nodes()) : log.info("No nodes found for", T), T.edges().length > 0 && log.info("Recursive edges", T.edge(T.edges()[0]));
+	let F = P.insert("g").attr("class", "clusters"), I = P.insert("g").attr("class", "edgePaths"), L = P.insert("g").attr("class", "edgeLabels"), R = P.insert("g").attr("class", "nodes");
+	await Promise.all(T.nodes().map(async function(r) {
+		let w = T.node(r);
+		if (k !== void 0) {
+			let w = JSON.parse(JSON.stringify(k.clusterData));
+			log.trace("Setting data for parent cluster XXX\n Node.id = ", r, "\n data=", w.height, "\nParent cluster", k.height), T.setNode(k.id, w), T.parent(r) || (log.trace("Setting parent", r, k.id), T.setParent(r, k.id, w));
+		}
+		if (log.info("(Insert) Node XXX" + r + ": " + JSON.stringify(T.node(r))), w?.clusterNode) {
+			log.info("Cluster identified XBX", r, w.width, T.node(r));
+			let { ranksep: E, nodesep: k } = T.graph();
+			w.graph.setGraph({
+				...w.graph.graph(),
+				ranksep: E + 25,
+				nodesep: k
+			});
+			let A = await recursiveRender(R, w.graph, D, O, T.node(r), M), j = A.elem;
+			updateNodeBounds(w, j), w.diff = A.diff || 0, log.info("New compound node after recursive render XAX", r, "width", w.width, "height", w.height), setNodeElem(j, w);
+		} else T.children(r).length > 0 ? (log.trace("Cluster - the non recursive path XBX", r, w.id, w, w.width, "Graph:", T), log.trace(findNonClusterChild(w.id, T)), clusterDb.set(w.id, {
+			id: findNonClusterChild(w.id, T),
+			node: w
+		})) : (log.trace("Node - the non recursive path XAX", r, R, T.node(r), N), await insertNode(R, T.node(r), {
+			config: M,
+			dir: N
+		}));
+	})), await (/* @__PURE__ */ __name(async () => {
+		let r = T.edges().map(async function(r) {
+			let w = T.edge(r.v, r.w, r.name);
+			log.info("Edge " + r.v + " -> " + r.w + ": " + JSON.stringify(r)), log.info("Edge " + r.v + " -> " + r.w + ": ", r, " ", JSON.stringify(T.edge(r))), log.info("Fix", clusterDb, "ids:", r.v, r.w, "Translating: ", clusterDb.get(r.v), clusterDb.get(r.w)), await insertEdgeLabel(L, w);
+		});
+		await Promise.all(r);
+	}, "processEdges"))(), log.info("Graph before layout:", JSON.stringify(write(T))), log.info("############################################# XXX"), log.info("###                Layout                 ### XXX"), log.info("############################################# XXX"), layout(T), log.info("Graph after layout:", JSON.stringify(write(T)));
+	let z = 0, { subGraphTitleTotalMargin: B } = getSubGraphTitleMargins(M);
+	return await Promise.all(sortNodesByHierarchy(T).map(async function(r) {
+		let w = T.node(r);
+		if (log.info("Position XBX => " + r + ": (" + w.x, "," + w.y, ") width: ", w.width, " height: ", w.height), w?.clusterNode) w.y += B, log.info("A tainted cluster node XBX1", r, w.id, w.width, w.height, w.x, w.y, T.parent(r)), clusterDb.get(w.id).node = w, positionNode(w);
+		else if (T.children(r).length > 0) {
+			log.info("A pure cluster node XBX1", r, w.id, w.x, w.y, w.width, w.height, T.parent(r)), w.height += B, T.node(w.parentId);
+			let E = w?.padding / 2 || 0, D = w?.labelBBox?.height || 0, O = D - E || 0;
+			log.debug("OffsetY", O, "labelHeight", D, "halfPadding", E), await insertCluster(F, w), clusterDb.get(w.id).node = w;
+		} else {
+			let r = T.node(w.parentId);
+			w.y += B / 2, log.info("A regular node XBX1 - using the padding", w.id, "parent", w.parentId, w.width, w.height, w.x, w.y, "offsetY", w.offsetY, "parent", r, r?.offsetY, w), positionNode(w);
+		}
+	})), T.edges().forEach(function(r) {
+		let w = T.edge(r);
+		log.info("Edge " + r.v + " -> " + r.w + ": " + JSON.stringify(w), w), w.points.forEach((r) => r.y += B / 2), positionEdgeLabel(w, insertEdge(I, w, clusterDb, D, T.node(r.v), T.node(r.w), O));
+	}), T.nodes().forEach(function(r) {
+		let w = T.node(r);
+		log.info(r, w.type, w.diff), w.isGroup && (z = w.diff);
+	}), log.warn("Returning from recursive render XAX", P, z), {
+		elem: P,
+		diff: z
+	};
+}, "recursiveRender"), render = /* @__PURE__ */ __name(async (r, w) => {
+	let E = new Graph({
+		multigraph: !0,
+		compound: !0
+	}).setGraph({
+		rankdir: r.direction,
+		nodesep: r.config?.nodeSpacing || r.config?.flowchart?.nodeSpacing || r.nodeSpacing,
+		ranksep: r.config?.rankSpacing || r.config?.flowchart?.rankSpacing || r.rankSpacing,
+		marginx: 8,
+		marginy: 8
+	}).setDefaultEdgeLabel(function() {
+		return {};
+	}), D = w.select("g");
+	markers_default(D, r.markers, r.type, r.diagramId), clear2(), clear(), clear$1(), clear4(), r.nodes.forEach((r) => {
+		E.setNode(r.id, { ...r }), r.parentId && E.setParent(r.id, r.parentId);
+	}), log.debug("Edges:", r.edges), r.edges.forEach((r) => {
+		if (r.start === r.end) {
+			let C = r.start, w = C + "---" + C + "---1", T = C + "---" + C + "---2", D = E.node(C);
+			E.setNode(w, {
+				domId: w,
+				id: w,
+				parentId: D.parentId,
+				labelStyle: "",
+				label: "",
+				padding: 0,
+				shape: "labelRect",
+				style: "",
+				width: 10,
+				height: 10
+			}), E.setParent(w, D.parentId), E.setNode(T, {
+				domId: T,
+				id: T,
+				parentId: D.parentId,
+				labelStyle: "",
+				padding: 0,
+				shape: "labelRect",
+				label: "",
+				style: "",
+				width: 10,
+				height: 10
+			}), E.setParent(T, D.parentId);
+			let O = structuredClone(r), k = structuredClone(r), A = structuredClone(r);
+			O.label = "", O.arrowTypeEnd = "none", O.id = C + "-cyclic-special-1", k.arrowTypeStart = "none", k.arrowTypeEnd = "none", k.id = C + "-cyclic-special-mid", A.label = "", D.isGroup && (O.fromCluster = C, A.toCluster = C), A.id = C + "-cyclic-special-2", A.arrowTypeStart = "none", E.setEdge(C, w, O, C + "-cyclic-special-0"), E.setEdge(w, T, k, C + "-cyclic-special-1"), E.setEdge(T, C, A, C + "-cyc<lic-special-2");
+		} else E.setEdge(r.start, r.end, { ...r }, r.id);
+	}), log.warn("Graph at first:", JSON.stringify(write(E))), adjustClustersAndEdges(E), log.warn("Graph after XAX:", JSON.stringify(write(E)));
+	let k = getConfig2();
+	await recursiveRender(D, E, r.type, r.diagramId, void 0, k);
+}, "render");
+export { render };