likec4 1.48.0 → 1.50.0

package/dist/_chunks/sequence-view.mjs

@@ -1,575 +0,0 @@
-import { G as t$7, M as t$8, N as t$1, d as t$6, g as t$4, h as t$5, p as t$2, q as t, t as t$3, z as n } from "./libs/remeda.mjs";
-import { a as Variable, i as Strength, n as Constraint, r as Operator, t as Solver } from "./libs/@lume/kiwi.mjs";
-import { getParallelStepsPrefix, isStepEdgeId } from "@likec4/core/types";
-import { DefaultMap, Stack, invariant, isAncestor, nonNullable, nonexhaustive } from "@likec4/core/utils";
-
-//#region ../layouts/src/sequence/const.ts
-const ACTOR_GAP = 60;
-const COLUMN_GAP = 32;
-const MIN_ROW_HEIGHT = 80;
-const PORT_HEIGHT = 32;
-const STEP_LABEL_MARGIN = 50;
-const FIRST_STEP_OFFSET = 30;
-const CONTINUOUS_OFFSET = 22;
-
-//#endregion
-//#region ../layouts/src/sequence/utils.ts
-/**
-* From steps find boxes that must be marked as parallel on the layout
-*/
-function findParallelRects(steps) {
-	return t(steps, t$1((s) => s.parallelPrefix ?? void 0), t$2((steps, parallelPrefix) => {
-		return steps.reduce((acc, step) => {
-			acc.min.column = Math.min(acc.min.column, step.from.column, step.to.column);
-			acc.min.row = Math.min(acc.min.row, step.from.row, step.to.row);
-			acc.max.column = Math.max(acc.max.column, step.from.column, step.to.column);
-			acc.max.row = Math.max(acc.max.row, step.from.row, step.to.row);
-			return acc;
-		}, {
-			parallelPrefix,
-			min: {
-				column: Infinity,
-				row: Infinity
-			},
-			max: {
-				column: -Infinity,
-				row: -Infinity
-			}
-		});
-	}), t$3());
-}
-/**
-* Builds a tree of compounds from actors and nodes.
-* @param actors the actors in the sequence view
-* @param nodes the nodes in likec4 diagram
-* @returns an array of compounds where each compound is a node in the sequence view
-* that is an ancestor of one of the actors
-*/
-function buildCompounds(actors, nodes) {
-	if (actors.length === 0 || actors.length === nodes.length) return [];
-	const getNode = (id) => nonNullable(nodes.find((n) => n.id === id));
-	function parentsLookup(node) {
-		const parent = node.parent ? getNode(node.parent) : null;
-		if (parent) return [parent, ...parentsLookup(parent)];
-		return [];
-	}
-	const stack = new Stack();
-	const result = [];
-	actors.forEach((actor) => {
-		const _ancestors = parentsLookup(actor);
-		if (_ancestors.length === 0) {
-			stack.clear();
-			return;
-		}
-		const ancestors = Stack.from(_ancestors);
-		let compound;
-		let parent;
-		while (true) {
-			compound = stack.peek()?.node;
-			parent = ancestors.peek();
-			if (!parent || !compound) break;
-			if (isAncestor(parent.id, compound.id) || parent.id === compound.id) {
-				ancestors.pop();
-				continue;
-			}
-			if (!isAncestor(compound.id, parent.id)) {
-				stack.pop();
-				continue;
-			}
-			break;
-		}
-		while (parent = ancestors.pop()) {
-			const parentAsCompound = {
-				node: parent,
-				from: actor,
-				to: actor,
-				nested: []
-			};
-			let compound = stack.peek();
-			if (!compound) result.push(parentAsCompound);
-			else compound.nested.push(parentAsCompound);
-			stack.push(parentAsCompound);
-		}
-		stack.forEach((c) => c.to = actor);
-	});
-	return result;
-}
-
-//#endregion
-//#region ../layouts/src/sequence/layouter.ts
-var SequenceViewLayouter = class {
-	#solver = new Solver();
-	#actors;
-	#compounds = [];
-	#viewportRight;
-	#viewportBottom;
-	#rowsTop;
-	#rows = [];
-	#parallelBoxes = [];
-	constructor({ actors, steps, compounds }) {
-		this.#rowsTop = this.newVar(FIRST_STEP_OFFSET);
-		this.#viewportRight = this.newVar(0);
-		this.#viewportBottom = this.newVar(0);
-		this.#actors = this.addActors(actors);
-		for (const compound of compounds) {
-			const result = this.addCompound(compound);
-			const toplevel = result[0];
-			this.constraint(toplevel.y1, "==", 0, Strength.strong);
-			this.put(this.#viewportBottom).after(toplevel.bottom);
-			this.put(this.#rowsTop).after(toplevel.y2);
-			this.#compounds.push(...result);
-		}
-		for (const step of steps) this.addStep(step);
-		for (const parallelRect of findParallelRects(steps)) this.addParallelRect(parallelRect);
-		const firstActor = this.#actors[0];
-		this.constraint(firstActor.offset.left, "==", 0, Strength.strong);
-		const lastActor = this.#actors.reduce((prev, actor) => {
-			this.put(actor.x).after(prev.right, ACTOR_GAP);
-			this.put(actor.offset.left, Strength.strong).after(prev.offset.right, COLUMN_GAP);
-			this.constraint(actor.centerY, "==", prev.centerY, Strength.strong);
-			this.put(this.#rowsTop).after(actor.offset.bottom);
-			return actor;
-		});
-		this.put(this.#viewportRight).after(lastActor.offset.right);
-		this.put(this.#viewportBottom).after(t$4(this.#rows)?.bottom ?? this.#rowsTop);
-		if (compounds.length > 0) for (const compound of this.#compounds) {
-			const from = compound.from.column;
-			const to = compound.to.column;
-			let maxRow = Math.max(compound.from.maxRow, compound.to.maxRow);
-			for (let i = from + 1; i < to; i++) {
-				const actorBox = this.actorBox(i);
-				maxRow = Math.max(maxRow, actorBox.maxRow);
-			}
-			const lastRow = nonNullable(this.#rows[maxRow], `row ${maxRow} not found`);
-			this.put(compound.bottom).after(lastRow.bottom, 16);
-			this.put(this.#viewportBottom).after(compound.bottom);
-		}
-		this.#solver.updateVariables();
-	}
-	getParallelBoxes() {
-		return this.#parallelBoxes.map(({ parallelPrefix, x1, y1, x2, y2 }) => ({
-			parallelPrefix,
-			x: x1.value(),
-			y: y1.value(),
-			width: x2.value() - x1.value(),
-			height: y2.value() - y1.value()
-		}));
-	}
-	getActorBox(actor) {
-		const actorBox = this.actorBox(actor);
-		return {
-			x: actorBox.x.value(),
-			y: actorBox.y.value(),
-			width: actorBox.width,
-			height: actorBox.height
-		};
-	}
-	getCompoundBoxes() {
-		return this.#compounds.map(({ node, depth, x1, y1, x2, bottom }) => ({
-			node,
-			depth,
-			x: x1.value(),
-			y: y1.value(),
-			width: x2.value() - x1.value(),
-			height: bottom.value() - y1.value()
-		}));
-	}
-	getPortCenter(step, type) {
-		const { column, row } = type === "source" ? step.from : step.to;
-		const x = this.actorBox(column).centerX;
-		const { y } = nonNullable(this.#rows[row]);
-		return {
-			cx: x.value(),
-			cy: y.value() + PORT_HEIGHT / 2 + step.offset,
-			height: type === "source" ? 40 : 24
-		};
-	}
-	getViewBounds() {
-		return {
-			x: 0,
-			y: 0,
-			width: this.#viewportRight.value(),
-			height: this.#viewportBottom.value()
-		};
-	}
-	actorBox(actor) {
-		if (typeof actor !== "number") {
-			const id = typeof actor === "string" ? actor : actor.id;
-			actor = this.#actors.findIndex((a) => a.actor.id === id);
-			invariant(actor >= 0, `actor ${id} not found`);
-		}
-		return nonNullable(this.#actors[actor], `actor at index ${actor} not found`);
-	}
-	addActors(actors) {
-		let accX = 0;
-		return t$5(actors, (actor, column) => {
-			const x = this.newVar(accX);
-			accX += actor.width + ACTOR_GAP;
-			const y = this.newVar(0);
-			const actorBox = {
-				column,
-				actor,
-				x,
-				y,
-				centerX: x.plus(Math.round(actor.width / 2)),
-				centerY: y.plus(Math.round(actor.height / 2)),
-				width: actor.width,
-				height: actor.height,
-				right: x.plus(actor.width),
-				bottom: y.plus(actor.height),
-				minRow: Infinity,
-				maxRow: -Infinity
-			};
-			const top = this.newVar(0), left = this.newVar(0), right = this.newVar(0), bottom = this.newVar(0);
-			this.put(top, Strength.strong).before(y);
-			this.put(left, Strength.strong).before(x);
-			this.put(right, Strength.strong).after(actorBox.right);
-			this.put(bottom, Strength.strong).after(actorBox.bottom);
-			return {
-				...actorBox,
-				offset: {
-					top,
-					left,
-					right,
-					bottom
-				}
-			};
-		});
-	}
-	addStep(step) {
-		const source = this.actorBox(step.source);
-		const target = this.actorBox(step.target);
-		source.minRow = Math.min(source.minRow, step.from.row);
-		source.maxRow = Math.max(source.maxRow, step.from.row);
-		target.minRow = Math.min(target.minRow, step.to.row);
-		target.maxRow = Math.max(target.maxRow, step.to.row);
-		const [left, right] = source.column <= target.column ? [source, target] : [target, source];
-		const width = (step.label?.width ?? 100) + STEP_LABEL_MARGIN;
-		if (left !== right) this.constraint(left.centerX.plus(width), "<=", right.centerX);
-		else this.constraint(left.centerX.plus(width), "<=", left.offset.right);
-		let height = step.label?.height ? step.label.height + STEP_LABEL_MARGIN + PORT_HEIGHT / 2 : MIN_ROW_HEIGHT;
-		height = Math.max(height, MIN_ROW_HEIGHT) + step.offset;
-		this.ensureRow(step.from.row, height);
-		if (step.isSelfLoop) this.ensureRow(step.to.row, MIN_ROW_HEIGHT);
-		return this;
-	}
-	addParallelRect({ parallelPrefix, min, max }) {
-		const x1 = this.actorBox(min.column).centerX.minus(30);
-		const x2 = this.actorBox(max.column).centerX.plus(30);
-		const firstRow = this.#rows[min.row];
-		const lastRow = this.#rows[max.row];
-		invariant(firstRow && lastRow, `parallel box invalid minRow=${min.row} maxRow=${max.row}`);
-		const y1 = this.newVar(0);
-		this.put(y1).before(firstRow.y, 40);
-		const y2 = lastRow.bottom;
-		const rowBefore = min.row > 0 && this.#rows[min.row - 1];
-		if (rowBefore) this.put(y1).after(rowBefore.bottom, 16);
-		const rowAfter = max.row < this.#rows.length - 1 && this.#rows[max.row + 1];
-		if (rowAfter) this.put(y2).before(rowAfter.y, 16);
-		this.#parallelBoxes.push({
-			parallelPrefix,
-			x1,
-			y1,
-			x2,
-			y2
-		});
-	}
-	addCompound(compound) {
-		const PADDING = 32;
-		const PADDING_TOP = 40;
-		const PADDING_TOP_FROM_ACTOR = 52;
-		const children = [];
-		const nested = compound.nested.flatMap((c) => {
-			const result = this.addCompound(c);
-			children.push(result[0]);
-			return result;
-		});
-		const depth = Math.max(...nested.map((c) => c.depth + 1), 0);
-		const from = this.actorBox(compound.from);
-		const to = this.actorBox(compound.to);
-		const x1 = from.offset.left.minus(PADDING);
-		from.offset.left = x1;
-		const x2 = to.offset.right.plus(PADDING);
-		to.offset.right = x2;
-		const bottom = this.newVar(0);
-		const onlyChild = t$6(children);
-		let y1, y2;
-		switch (true) {
-			case !!onlyChild:
-				y1 = onlyChild.y1.minus(PADDING_TOP);
-				y2 = onlyChild.y2.plus(PADDING);
-				this.put(bottom).after(onlyChild.bottom, PADDING);
-				break;
-			case to === from:
-				y1 = this.newVar(0);
-				y2 = this.newVar(0);
-				this.put(y1).before(from.offset.top, PADDING_TOP_FROM_ACTOR);
-				this.put(y2).after(from.offset.bottom, PADDING);
-				this.put(bottom).after(y2);
-				break;
-			case children.length > 0:
-				y1 = this.newVar(0);
-				y2 = this.newVar(0);
-				for (const child of children) {
-					this.put(y1).before(child.y1, PADDING);
-					this.put(y2).after(child.y2, PADDING);
-					this.put(bottom).after(child.bottom, PADDING);
-				}
-				break;
-			default:
-				y1 = this.newVar(0);
-				y2 = this.newVar(0);
-				for (var col = from.column; col <= to.column; col++) {
-					const offset = this.actorBox(col).offset;
-					this.put(y1).before(offset.top, PADDING_TOP_FROM_ACTOR);
-					this.put(y2).after(offset.bottom, PADDING);
-				}
-				this.put(bottom).after(y2);
-				break;
-		}
-		for (var col = from.column; col <= to.column; col++) {
-			const offset = this.actorBox(col).offset;
-			offset.top = y1;
-			offset.bottom = y2;
-		}
-		return [{
-			node: compound.node,
-			depth,
-			from,
-			to,
-			x1,
-			y1,
-			x2,
-			y2,
-			bottom
-		}, ...nested];
-	}
-	ensureRow(row, rowHeight) {
-		while (row >= this.#rows.length) {
-			const prevRowY = this.#rows.length > 0 && this.#rows[this.#rows.length - 1]?.bottom || this.#rowsTop.plus(FIRST_STEP_OFFSET);
-			const y = this.newVar(this.#rows.length * MIN_ROW_HEIGHT);
-			this.put(y).after(prevRowY);
-			const height = this.newVar(MIN_ROW_HEIGHT);
-			this.require(height, ">=", MIN_ROW_HEIGHT);
-			this.#rows.push({
-				y,
-				height,
-				bottom: y.plus(height),
-				lastHeight: MIN_ROW_HEIGHT
-			});
-		}
-		const rowVar = nonNullable(this.#rows[row]);
-		if (rowHeight > rowVar.lastHeight) {
-			rowVar.lastHeight = rowHeight;
-			this.require(rowVar.height, ">=", rowHeight);
-			this.#solver.suggestValue(rowVar.height, rowHeight);
-		}
-	}
-	newVar(initialValue) {
-		const v = new Variable();
-		this.#solver.addEditVariable(v, Strength.weak);
-		if (typeof initialValue === "number") {
-			this.#solver.suggestValue(v, initialValue);
-			this.constraint(v, ">=", 0, Strength.strong);
-		}
-		return v;
-	}
-	/**
-	* Adds a required constraint:
-	* Also adds a weak constraint == if the operator is <= or >=
-	*/
-	require(left, op, right = void 0) {
-		this.constraint(left, op, right, Strength.required);
-		switch (op) {
-			case "<=":
-			case ">=":
-				this.constraint(left, "==", right, Strength.weak);
-				break;
-			case "<= 0":
-			case ">= 0":
-				this.constraint(left, "== 0", void 0, Strength.weak);
-				break;
-		}
-	}
-	/**
-	* Adds a constraint with medium strength by default
-	*/
-	constraint(left, op, right = void 0, strength = Strength.medium) {
-		let operator;
-		switch (op) {
-			case "==":
-				operator = Operator.Eq;
-				break;
-			case ">=":
-				operator = Operator.Ge;
-				break;
-			case "<=":
-				operator = Operator.Le;
-				break;
-			case "== 0":
-				operator = Operator.Eq;
-				right = 0;
-				break;
-			case ">= 0":
-				operator = Operator.Ge;
-				right = 0;
-				break;
-			case "<= 0":
-				operator = Operator.Le;
-				right = 0;
-				break;
-			default: nonexhaustive(op);
-		}
-		this.#solver.addConstraint(new Constraint(left, operator, right ?? 0, strength));
-	}
-	put(variable, strength = Strength.required) {
-		const eqStrength = strength === Strength.required ? Strength.medium : Strength.weak;
-		return {
-			before: (other, gap) => {
-				if (gap) other = other.minus(gap);
-				this.constraint(variable, "<=", other, strength);
-				this.constraint(variable, "==", other, eqStrength);
-			},
-			after: (other, gap) => {
-				if (gap) other = other.plus(gap);
-				this.constraint(variable, ">=", other, strength);
-				this.constraint(variable, "==", other, eqStrength);
-			}
-		};
-	}
-};
-
-//#endregion
-//#region ../layouts/src/sequence/sequence-view.ts
-function calcSequenceLayout(view) {
-	const actorNodes = /* @__PURE__ */ new Set();
-	const getNode = (id) => nonNullable(view.nodes.find((n) => n.id === id));
-	const preparedSteps = [];
-	for (const edge of view.edges.filter((e) => isStepEdgeId(e.id))) {
-		const source = getNode(edge.source);
-		const target = getNode(edge.target);
-		if (source.children.length || target.children.length) {
-			console.error("Sequence view does not support nested actors");
-			continue;
-		}
-		actorNodes.add(source);
-		actorNodes.add(target);
-		preparedSteps.push({
-			edge,
-			source,
-			target
-		});
-	}
-	const actors = view.nodes.filter((n) => actorNodes.has(n));
-	invariant(t$7(actors, 1), "actors array must not be empty");
-	const actorPorts = new DefaultMap(() => []);
-	const steps = [];
-	let row = 0;
-	for (const { edge, source, target } of preparedSteps) {
-		const prevStep = steps.at(-1);
-		let sourceColumn = actors.indexOf(source);
-		let targetColumn = actors.indexOf(target);
-		const isSelfLoop = source === target;
-		const isBack = sourceColumn > targetColumn;
-		const parallelPrefix = getParallelStepsPrefix(edge.id);
-		let isContinuing = false;
-		if (prevStep && prevStep.target == source && prevStep.parallelPrefix === parallelPrefix) isContinuing = prevStep.isSelfLoop !== isSelfLoop || prevStep.isBack === isBack;
-		if (!isContinuing) row++;
-		const step = {
-			id: edge.id,
-			from: {
-				column: sourceColumn,
-				row
-			},
-			to: {
-				column: targetColumn,
-				row: isSelfLoop ? ++row : row
-			},
-			edge,
-			isSelfLoop,
-			isBack,
-			parallelPrefix,
-			offset: isContinuing ? (prevStep?.offset ?? 0) + CONTINUOUS_OFFSET : 0,
-			source,
-			target,
-			label: edge.labelBBox ? {
-				height: edge.labelBBox.height + 8 + (edge.navigateTo ? 20 : 0),
-				width: edge.labelBBox.width + 16,
-				text: edge.label
-			} : null
-		};
-		steps.push(step);
-		actorPorts.get(source).push({
-			step,
-			row,
-			type: "source",
-			position: isBack && !isSelfLoop ? "left" : "right"
-		});
-		actorPorts.get(target).push({
-			step,
-			row,
-			type: "target",
-			position: isBack || isSelfLoop ? "right" : "left"
-		});
-	}
-	const layout = new SequenceViewLayouter({
-		actors,
-		steps,
-		compounds: buildCompounds(actors, view.nodes)
-	});
-	const bounds = layout.getViewBounds();
-	const compounds = t(layout.getCompoundBoxes(), t$5(({ node, ...box }) => ({
-		...box,
-		id: node.id,
-		origin: node.id
-	})), t$8("id"), t$2((boxes, id) => {
-		if (t$7(boxes, 2)) return t$5(boxes, (box, i) => ({
-			...box,
-			id: `${id}-${i + 1}`
-		}));
-		return boxes;
-	}), t$3(), n());
-	return {
-		actors: actors.map((actor) => toSeqActor({
-			actor,
-			ports: actorPorts.get(actor),
-			layout
-		})),
-		compounds,
-		steps: t$5(steps, (s) => ({
-			id: s.id,
-			sourceHandle: s.id + "_source",
-			targetHandle: s.id + "_target",
-			...s.label && { labelBBox: {
-				width: s.label.width,
-				height: s.label.height
-			} }
-		})),
-		parallelAreas: layout.getParallelBoxes(),
-		bounds
-	};
-}
-function toSeqActor({ actor, ports, layout }) {
-	const { x, y, width, height } = layout.getActorBox(actor);
-	return {
-		id: actor.id,
-		x,
-		y,
-		width,
-		height,
-		ports: ports.map((p) => {
-			const bbox = layout.getPortCenter(p.step, p.type);
-			return {
-				id: `${p.step.id}_${p.type}`,
-				cx: bbox.cx - x,
-				cy: bbox.cy - y,
-				height: bbox.height,
-				type: p.type,
-				position: p.position
-			};
-		})
-	};
-}
-
-//#endregion
-export { calcSequenceLayout as t };

package/dist/_chunks/vite-build.mjs

@@ -1,69 +0,0 @@
-import { t as u } from "./libs/tinyrainbow.mjs";
-import { a as mkTempPublicDir, t as viteConfig } from "./config-app.prod.mjs";
-import { t as viteWebcomponentConfig } from "./config-webcomponent.prod.mjs";
-import { copyFileSync, existsSync, readdirSync, rmSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { build } from "vite";
-
-//#region src/vite/vite-build.ts
-const Assets = ["favicon.ico", "robots.txt"];
-async function viteBuild({ buildWebcomponent = true, webcomponentPrefix = "likec4", title, languageServices, likec4AssetsDir, outputSingleFile, ...cfg }) {
-	likec4AssetsDir ??= await mkdtemp(join(tmpdir(), ".likec4-assets-"));
-	const config = await viteConfig({
-		...cfg,
-		languageServices,
-		likec4AssetsDir,
-		webcomponentPrefix,
-		title,
-		outputSingleFile
-	});
-	const outDirWasEmpty = !existsSync(config.build.outDir) || readdirSync(config.build.outDir).length === 0;
-	const publicDir = await mkTempPublicDir();
-	for (const asset of Assets) {
-		const origin = resolve(config.root, asset);
-		if (existsSync(origin)) copyFileSync(origin, resolve(publicDir, asset));
-	}
-	const projects = languageServices.languageServices.projects();
-	if (projects.length === 1) {
-		const computed = await languageServices.viewsService.computedViews();
-		const diagrams = await languageServices.diagrams();
-		if (diagrams.length === 0) {
-			process.exitCode = 1;
-			throw new Error("no views found");
-		}
-		if (diagrams.length === computed.length) config.customLogger.info(`${u.dim("workspace:")} ${u.green(`✓ all views layouted`)}`);
-		else config.customLogger.warn(`${u.dim("workspace:")} ${u.yellow(`✗ layouted ${diagrams.length} of ${computed.length} views`)}`);
-		diagrams.forEach((view) => {
-			if (view.hasLayoutDrift || !!view.drifts && view.drifts.length > 0) config.customLogger.warn(u.dim("view") + " " + u.red(view.id) + " " + u.yellow(`is out of date, layout drift detected`));
-		});
-	} else for (const project of projects) {
-		const computed = await languageServices.viewsService.computedViews(project.id);
-		if (computed.length === 0) config.customLogger.warn(`${u.dim("project:")} ${project.id} ${u.yellow(`✗ no views found`)}`);
-		else config.customLogger.info(`${u.dim("project:")} ${project.id} ${u.green(`${computed.length} views`)}`);
-	}
-	if (buildWebcomponent && !outputSingleFile) await build(await viteWebcomponentConfig({
-		webcomponentPrefix,
-		languageServices,
-		outDir: publicDir,
-		base: config.base
-	}));
-	await build({
-		...config,
-		publicDir,
-		mode: "production"
-	});
-	if (outputSingleFile) {
-		if (!outDirWasEmpty) {
-			config.customLogger.warn(u.yellow("outDir was not empty, skipping cleanup"));
-			return;
-		}
-		for (let extraFile of readdirSync(resolve(config.build.outDir)).filter((f) => f !== "index.html")) rmSync(resolve(config.build.outDir, extraFile), { recursive: true });
-	}
-	const indexHtml = resolve(config.build.outDir, "index.html");
-	if (existsSync(indexHtml)) copyFileSync(indexHtml, resolve(config.build.outDir, "404.html"));
-}
-
-//#endregion
-export { viteBuild as n, Assets as t };