@likec4/core 1.47.0 → 1.48.0

package/dist/_chunks/find.mjs

@@ -0,0 +1,646 @@
+import { n as __exportAll } from "./rolldown-runtime.mjs";
+import { D as e$1, F as e$2, I as e, i as n, k as t } from "./libs/remeda.mjs";
+import { I as exact } from "./LikeC4Styles.mjs";
+import { E as nameFromFqn, S as hierarchyLevel, T as isSameHierarchy, a as difference, c as intersection, h as memoizeProp, o as equals, r as stringHash, u as union, v as commonAncestor } from "./utils.mjs";
+import { n as nonNullable, t as invariant } from "./invariant.mjs";
+import { s as ihead } from "./iterable.mjs";
+import { n as preferSummary, t as preferDescription } from "./_aux.mjs";
+import { t as RichText } from "./RichText.mjs";
+import { t as customInspectSymbol } from "./const.mjs";
+
+//#region src/model/DeploymentElementModel.ts
+var AbstractDeploymentElementModel = class {
+	/**
+	* Don't use in runtime, only for type inference
+	*/
+	Aux;
+	get style() {
+		return memoizeProp(this, "style", () => exact({
+			shape: this.$model.$styles.defaults.shape,
+			color: this.$model.$styles.defaults.color,
+			border: this.$model.$styles.defaults.border,
+			opacity: this.$model.$styles.defaults.opacity,
+			size: this.$model.$styles.defaults.size,
+			padding: this.$model.$styles.defaults.padding,
+			textSize: this.$model.$styles.defaults.text,
+			...this.$node.style
+		}));
+	}
+	get name() {
+		return nameFromFqn(this.id);
+	}
+	get shape() {
+		return this.style.shape;
+	}
+	get color() {
+		return this.style.color;
+	}
+	get icon() {
+		return this.style.icon ?? null;
+	}
+	/**
+	* Short description of the element.
+	* Falls back to description if summary is not provided.
+	*/
+	get summary() {
+		return RichText.memoize(this, "summary", /* @__PURE__ */ preferSummary(this.$node));
+	}
+	/**
+	* Long description of the element.
+	* Falls back to summary if description is not provided.
+	*/
+	get description() {
+		return RichText.memoize(this, "description", /* @__PURE__ */ preferDescription(this.$node));
+	}
+	get technology() {
+		return this.$node.technology ?? null;
+	}
+	get links() {
+		return this.$node.links ?? [];
+	}
+	/**
+	* Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+	* (from closest to root)
+	*/
+	ancestors() {
+		return this.$model.ancestors(this);
+	}
+	/**
+	* Returns the common ancestor of this element and another element.
+	*/
+	commonAncestor(another) {
+		const common = commonAncestor(this.id, another.id);
+		return common ? this.$model.node(common) : null;
+	}
+	/**
+	* Get all sibling (i.e. same parent)
+	*/
+	siblings() {
+		return this.$model.siblings(this);
+	}
+	/**
+	* Check if the element is a sibling of another element
+	*/
+	isSibling(other) {
+		return this.parent === other.parent;
+	}
+	/**
+	* Resolve siblings of the element and its ancestors
+	*  (from closest to root)
+	*/
+	*ascendingSiblings() {
+		yield* this.siblings();
+		for (const ancestor of this.ancestors()) yield* ancestor.siblings();
+	}
+	/**
+	* Resolve siblings of the element and its ancestors
+	*  (from root to closest)
+	*/
+	*descendingSiblings() {
+		for (const ancestor of [...this.ancestors()].reverse()) yield* ancestor.siblings();
+		yield* this.siblings();
+	}
+	incoming(filter = "all") {
+		return this.$model.incoming(this, filter);
+	}
+	outgoing(filter = "all") {
+		return this.$model.outgoing(this, filter);
+	}
+	*incomers(filter = "all") {
+		const unique = /* @__PURE__ */ new Set();
+		for (const r of this.incoming(filter)) {
+			if (unique.has(r.source.id)) continue;
+			unique.add(r.source.id);
+			yield r.source;
+		}
+	}
+	*outgoers(filter = "all") {
+		const unique = /* @__PURE__ */ new Set();
+		for (const r of this.outgoing(filter)) {
+			if (unique.has(r.target.id)) continue;
+			unique.add(r.target.id);
+			yield r.target;
+		}
+	}
+	/**
+	* Iterate over all views that include this deployment element.
+	*/
+	*views() {
+		for (const view of this.$model.views()) {
+			if (view._type !== "deployment") continue;
+			if (view.includesDeployment(this.id)) yield view;
+		}
+	}
+	isDeploymentNode() {
+		return false;
+	}
+	isInstance() {
+		return false;
+	}
+	get allOutgoing() {
+		return memoizeProp(this, Symbol.for("allOutgoing"), () => RelationshipsAccum.from(new Set(this.outgoingModelRelationships()), new Set(this.outgoing())));
+	}
+	get allIncoming() {
+		return memoizeProp(this, Symbol.for("allIncoming"), () => RelationshipsAccum.from(new Set(this.incomingModelRelationships()), new Set(this.incoming())));
+	}
+	hasMetadata() {
+		return !!this.$node.metadata && !e(this.$node.metadata);
+	}
+	getMetadata(field) {
+		if (field) return this.$node.metadata?.[field];
+		return this.$node.metadata ?? {};
+	}
+	/**
+	* Checks if the deployment element has the given tag.
+	*/
+	isTagged(tag) {
+		return this.tags.includes(tag);
+	}
+};
+var DeploymentNodeModel = class extends AbstractDeploymentElementModel {
+	id;
+	_literalId;
+	title;
+	hierarchyLevel;
+	constructor($model, $node) {
+		super();
+		this.$model = $model;
+		this.$node = $node;
+		this.id = $node.id;
+		this._literalId = $node.id;
+		this.title = $node.title;
+		this.hierarchyLevel = hierarchyLevel($node.id);
+	}
+	get parent() {
+		return this.$model.parent(this);
+	}
+	get kind() {
+		return this.$node.kind;
+	}
+	get tags() {
+		return memoizeProp(this, Symbol.for("tags"), () => {
+			return n([...this.$node.tags ?? [], ...this.$model.$model.specification.deployments[this.kind]?.tags ?? []]);
+		});
+	}
+	children() {
+		return this.$model.children(this);
+	}
+	descendants(sort = "desc") {
+		return this.$model.descendants(this, sort);
+	}
+	isDeploymentNode() {
+		return true;
+	}
+	/**
+	* Iterate over all instances nested in this deployment node.
+	*/
+	*instances() {
+		for (const nested of this.descendants("desc")) if (nested.isInstance()) yield nested;
+	}
+	/**
+	* Returns deployed instance inside this deployment node
+	* if only there are no more instances
+	*/
+	onlyOneInstance() {
+		const children = this.children();
+		if (children.size !== 1) return null;
+		const child = ihead(children);
+		if (!child) return null;
+		return child.isInstance() ? child : child.onlyOneInstance();
+	}
+	/**
+	* Cached result of relationships from instances
+	*/
+	_relationshipsFromInstances = null;
+	relationshipsFromInstances() {
+		if (this._relationshipsFromInstances) return this._relationshipsFromInstances;
+		const { outgoing, incoming } = this._relationshipsFromInstances = {
+			outgoing: /* @__PURE__ */ new Set(),
+			incoming: /* @__PURE__ */ new Set()
+		};
+		for (const instance of this.instances()) {
+			for (const r of instance.element.outgoing()) outgoing.add(r);
+			for (const r of instance.element.incoming()) incoming.add(r);
+		}
+		return this._relationshipsFromInstances;
+	}
+	/**
+	* We return only relationships that are not already present in nested instances
+	*/
+	outgoingModelRelationships() {
+		return this.relationshipsFromInstances().outgoing.values();
+	}
+	/**
+	* We return only relationships that are not already present in nested instances
+	*/
+	incomingModelRelationships() {
+		return this.relationshipsFromInstances().incoming.values();
+	}
+	/**
+	* Returns an iterator of relationships between nested instances
+	*/
+	internalModelRelationships() {
+		const { outgoing, incoming } = this.relationshipsFromInstances();
+		return intersection(incoming, outgoing);
+	}
+};
+var DeployedInstanceModel = class extends AbstractDeploymentElementModel {
+	id;
+	_literalId;
+	title;
+	hierarchyLevel;
+	constructor($model, $instance, element) {
+		super();
+		this.$model = $model;
+		this.$instance = $instance;
+		this.element = element;
+		this.id = $instance.id;
+		this._literalId = $instance.id;
+		this.title = $instance.title ?? element.title;
+		this.hierarchyLevel = hierarchyLevel($instance.id);
+	}
+	get $node() {
+		return this.$instance;
+	}
+	get parent() {
+		return nonNullable(this.$model.parent(this), `Parent of ${this.id} not found`);
+	}
+	get style() {
+		return memoizeProp(this, "style", () => exact({
+			shape: this.$model.$styles.defaults.shape,
+			color: this.$model.$styles.defaults.color,
+			border: this.$model.$styles.defaults.border,
+			opacity: this.$model.$styles.defaults.opacity,
+			size: this.$model.$styles.defaults.size,
+			padding: this.$model.$styles.defaults.padding,
+			textSize: this.$model.$styles.defaults.text,
+			...this.element.$element.style,
+			...this.$instance.style
+		}));
+	}
+	get tags() {
+		return memoizeProp(this, Symbol.for("tags"), () => {
+			return n([...this.$instance.tags ?? [], ...this.element.tags]);
+		});
+	}
+	get kind() {
+		return this.element.kind;
+	}
+	get summary() {
+		return RichText.memoize(this, "summary", /* @__PURE__ */ preferSummary(this.$instance) ?? /* @__PURE__ */ preferSummary(this.element.$element));
+	}
+	get description() {
+		return RichText.memoize(this, "description", /* @__PURE__ */ preferDescription(this.$instance) ?? /* @__PURE__ */ preferDescription(this.element.$element));
+	}
+	get technology() {
+		return this.$instance.technology ?? this.element.technology ?? null;
+	}
+	get links() {
+		return this.$instance.links ?? this.element.links;
+	}
+	isInstance() {
+		return true;
+	}
+	outgoingModelRelationships() {
+		return this.element.outgoing();
+	}
+	incomingModelRelationships() {
+		return this.element.incoming();
+	}
+	/**
+	* Iterate over all views that include this instance.
+	* (Some views may include the parent deployment node instead of the instance.)
+	*/
+	*views() {
+		for (const view of this.$model.views()) {
+			if (view._type !== "deployment") continue;
+			if (view.includesDeployment(this.id)) {
+				yield view;
+				continue;
+			}
+			if (view.includesDeployment(this.parent.id) && this.parent.onlyOneInstance()) yield view;
+		}
+	}
+};
+var NestedElementOfDeployedInstanceModel = class {
+	constructor(instance, element) {
+		this.instance = instance;
+		this.element = element;
+	}
+	get id() {
+		return this.instance.id;
+	}
+	get _literalId() {
+		return this.instance.id;
+	}
+	get style() {
+		return memoizeProp(this, "style ", () => ({
+			shape: this.element.shape,
+			color: this.element.color,
+			...this.element.$element.style
+		}));
+	}
+	get shape() {
+		return this.element.shape;
+	}
+	get color() {
+		return this.element.color;
+	}
+	get title() {
+		return this.element.title;
+	}
+	get summary() {
+		return this.element.summary;
+	}
+	get description() {
+		return this.element.description;
+	}
+	get technology() {
+		return this.element.technology;
+	}
+	isDeploymentNode() {
+		return false;
+	}
+	isInstance() {
+		return false;
+	}
+};
+var DeploymentRelationModel = class {
+	boundary;
+	source;
+	target;
+	constructor($model, $relationship) {
+		this.$model = $model;
+		this.$relationship = $relationship;
+		this.source = $model.deploymentRef($relationship.source);
+		this.target = $model.deploymentRef($relationship.target);
+		const parent = commonAncestor(this.source.id, this.target.id);
+		this.boundary = parent ? this.$model.node(parent) : null;
+	}
+	get id() {
+		return this.$relationship.id;
+	}
+	get expression() {
+		return `${this.source.id} -> ${this.target.id}`;
+	}
+	get title() {
+		if (!e$1(this.$relationship.title)) return null;
+		return this.$relationship.title;
+	}
+	get technology() {
+		if (e$2(this.$relationship.technology)) return (this.kind && this.$model.specification.relationships[this.kind])?.technology ?? null;
+		return this.$relationship.technology;
+	}
+	/**
+	* Returns true if the relationship has a summary and a description
+	* (if one is missing - it falls back to another)
+	*/
+	get hasSummary() {
+		return !!this.$relationship.summary && !!this.$relationship.description && !t(this.$relationship.summary, this.$relationship.description);
+	}
+	/**
+	* Short description of the relationship.
+	* Falls back to description if summary is not provided.
+	*/
+	get summary() {
+		return RichText.memoize(this, "summary", /* @__PURE__ */ preferSummary(this.$relationship));
+	}
+	/**
+	* Long description of the relationship.
+	* Falls back to summary if description is not provided.
+	*/
+	get description() {
+		return RichText.memoize(this, "description", /* @__PURE__ */ preferDescription(this.$relationship));
+	}
+	get tags() {
+		return this.$relationship.tags ?? [];
+	}
+	get kind() {
+		return this.$relationship.kind ?? null;
+	}
+	get navigateTo() {
+		return this.$relationship.navigateTo ? this.$model.$model.view(this.$relationship.navigateTo) : null;
+	}
+	get links() {
+		return this.$relationship.links ?? [];
+	}
+	get color() {
+		return this.$relationship.color ?? this.$model.$styles.defaults.relationship.color;
+	}
+	get line() {
+		return this.$relationship.line ?? this.$model.$styles.defaults.relationship.line;
+	}
+	get head() {
+		return this.$relationship.head ?? this.$model.$styles.defaults.relationship.arrow;
+	}
+	get tail() {
+		return this.$relationship.tail;
+	}
+	*views() {
+		for (const view of this.$model.views()) if (view.includesRelation(this.id)) yield view;
+	}
+	isDeploymentRelation() {
+		return true;
+	}
+	isModelRelation() {
+		return false;
+	}
+	hasMetadata() {
+		return !!this.$relationship.metadata && !e(this.$relationship.metadata);
+	}
+	getMetadata(field) {
+		if (field) return this.$relationship.metadata?.[field];
+		return this.$relationship.metadata ?? {};
+	}
+	/**
+	* Checks if the relationship has the given tag.
+	*/
+	isTagged(tag) {
+		return this.tags.includes(tag);
+	}
+};
+var RelationshipsAccum = class RelationshipsAccum {
+	static empty() {
+		return new RelationshipsAccum();
+	}
+	static from(model, deployment) {
+		return new RelationshipsAccum(new Set(model), new Set(deployment));
+	}
+	/**
+	* @param model relationships from logical model
+	* @param deployment relationships from deployment model
+	*/
+	constructor(model = /* @__PURE__ */ new Set(), deployment = /* @__PURE__ */ new Set()) {
+		this.model = model;
+		this.deployment = deployment;
+	}
+	get isEmpty() {
+		return this.model.size === 0 && this.deployment.size === 0;
+	}
+	get nonEmpty() {
+		return this.model.size > 0 || this.deployment.size > 0;
+	}
+	get size() {
+		return this.model.size + this.deployment.size;
+	}
+	/**
+	* Returns new Accum containing all the elements which are both in this and otherAccum
+	*/
+	intersect(otherAccum) {
+		return RelationshipsAccum.from(intersection(this.model, otherAccum.model), intersection(this.deployment, otherAccum.deployment));
+	}
+	/**
+	* Returns new Accum containing all the elements which are both in this and otherAccum
+	*/
+	difference(otherAccum) {
+		return RelationshipsAccum.from(difference(this.model, otherAccum.model), difference(this.deployment, otherAccum.deployment));
+	}
+	/**
+	* Returns new Accum containing all the elements from both
+	*/
+	union(otherAccum) {
+		return RelationshipsAccum.from(union(this.model, otherAccum.model), union(this.deployment, otherAccum.deployment));
+	}
+};
+
+//#endregion
+//#region src/model/connection/deployment/DeploymentConnectionModel.ts
+/**
+* Connection is ephemeral entity, result of a resolving relationships between source and target.
+* Includes direct relationships and/or between their nested elements.
+*/
+var DeploymentConnectionModel = class DeploymentConnectionModel {
+	id;
+	constructor(source, target, relations) {
+		this.source = source;
+		this.target = target;
+		this.relations = relations;
+		this.id = stringHash(`deployment:${source.id}:${target.id}`);
+	}
+	/**
+	* Human readable expression of the connection
+	* Mostly used for testing and debugging
+	*/
+	get expression() {
+		return `${this.source.id} -> ${this.target.id}`;
+	}
+	_boundary;
+	/**
+	* Common ancestor of the source and target elements.
+	* Represents the boundary of the connection.
+	*/
+	get boundary() {
+		this._boundary ??= this.source.commonAncestor(this.target);
+		return this._boundary;
+	}
+	nonEmpty() {
+		return this.relations.nonEmpty;
+	}
+	[customInspectSymbol](_depth, _inspectOptions, _inspect) {
+		const asString = this.toString();
+		Object.defineProperty(asString, "constructor", {
+			value: DeploymentConnectionModel,
+			enumerable: false
+		});
+		return asString;
+	}
+	toString() {
+		const model = [...this.relations.model].map((c) => "    " + c.expression);
+		if (model.length) model.unshift("  model:");
+		else model.unshift("  model: []");
+		const deployment = [...this.relations.deployment].map((c) => "    " + c.expression);
+		if (deployment.length) deployment.unshift("  deployment:");
+		else deployment.unshift("  deployment: []");
+		return [
+			this.expression,
+			...model,
+			...deployment
+		].join("\n");
+	}
+	/**
+	* Check if connection contains deployment relation,
+	* that is directly connected to source or target.
+	*/
+	hasDirectDeploymentRelation() {
+		for (const relation of this.relations.deployment) if (relation.source.id === this.source.id || relation.target.id === this.target.id) return true;
+		return false;
+	}
+	*values() {
+		yield* this.relations.model;
+		yield* this.relations.deployment;
+	}
+	mergeWith(other) {
+		if (Array.isArray(other)) return other.reduce((acc, o) => acc.mergeWith(o), this);
+		invariant(this.source.id === other.source.id, "Cannot merge connections with different sources");
+		invariant(this.target.id === other.target.id, "Cannot merge connections with different targets");
+		return new DeploymentConnectionModel(this.source, this.target, this.relations.union(other.relations));
+	}
+	difference(other) {
+		return new DeploymentConnectionModel(this.source, this.target, this.relations.difference(other.relations));
+	}
+	intersect(other) {
+		return new DeploymentConnectionModel(this.source, this.target, this.relations.intersect(other.relations));
+	}
+	equals(other) {
+		invariant(other instanceof DeploymentConnectionModel, "Other should ne DeploymentConnectionModel");
+		return this.id === other.id && this.source.id === other.source.id && this.target.id === other.target.id && equals(this.relations.model, other.relations.model) && equals(this.relations.deployment, other.relations.deployment);
+	}
+	/**
+	* Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
+	* if `null` is provided in overrides, the corresponding relation set will be empty.
+	*/
+	update(overrides) {
+		if (overrides) overrides = {
+			model: this.relations.model,
+			deployment: this.relations.deployment,
+			...overrides
+		};
+		return new DeploymentConnectionModel(this.source, this.target, overrides ? new RelationshipsAccum(overrides.model ?? /* @__PURE__ */ new Set(), overrides.deployment ?? /* @__PURE__ */ new Set()) : this.relations);
+	}
+};
+
+//#endregion
+//#region src/model/connection/deployment/find.ts
+var find_exports = /* @__PURE__ */ __exportAll({
+	findConnection: () => findConnection,
+	findConnectionsBetween: () => findConnectionsBetween,
+	findConnectionsWithin: () => findConnectionsWithin
+});
+function findConnection(source, target, direction = "directed") {
+	if (source === target) return [];
+	if (isSameHierarchy(source, target)) return [];
+	const directedIntersection = source.allOutgoing.intersect(target.allIncoming);
+	const directed = directedIntersection.nonEmpty ? [new DeploymentConnectionModel(source, target, directedIntersection)] : [];
+	if (direction === "directed") return directed;
+	return [...directed, ...findConnection(target, source, "directed")];
+}
+/**
+* Resolve all connections between element and others
+* By default, look for both directions.
+*
+* @default direction both
+*/
+function findConnectionsBetween(element, others, direction = "both") {
+	if (element.allIncoming.isEmpty && element.allOutgoing.isEmpty) return [];
+	const outgoing = [];
+	const incoming = [];
+	for (const _other of others) {
+		if (element === _other) continue;
+		for (const found of findConnection(element, _other, direction)) if (found.source === element) outgoing.push(found);
+		else incoming.push(found);
+	}
+	return [...outgoing, ...incoming];
+}
+/**
+* Resolve all connections within a given set of elements
+*/
+function findConnectionsWithin(elements) {
+	return [...elements].reduce((acc, el, index, array) => {
+		if (index === array.length - 1) return acc;
+		acc.push(...findConnectionsBetween(el, array.slice(index + 1), "both"));
+		return acc;
+	}, []);
+}
+
+//#endregion
+export { DeploymentConnectionModel as a, DeploymentRelationModel as c, find_exports as i, NestedElementOfDeployedInstanceModel as l, findConnectionsBetween as n, DeployedInstanceModel as o, findConnectionsWithin as r, DeploymentNodeModel as s, findConnection as t, RelationshipsAccum as u };