@likec4/core 1.47.0 → 1.48.0

package/dist/_chunks/relationships-view.mjs

@@ -0,0 +1,132 @@
+import { Q as t } from "./libs/remeda.mjs";
+import { A as sortParentsFirst, C as isAncestor, w as isDescendantOf } from "./utils.mjs";
+import { n as nonNullable, t as invariant } from "./invariant.mjs";
+import { n as import_default_map } from "./libs/mnemonist.mjs";
+import { f as ifilter, n as toArray, o as imap, r as toSet } from "./iterable.mjs";
+
+//#region src/compute-view/relationships-view/utils.ts
+function treeFromElements(elements) {
+	const sorted = sortParentsFirst([...elements]);
+	const root = new Set(sorted);
+	const map = new Map(sorted.map((e) => [e._literalId, e]));
+	const parents = new import_default_map.default(() => null);
+	const children = sorted.reduce((acc, parent, index, all) => {
+		acc.set(parent, all.slice(index + 1).filter(isDescendantOf(parent)).map((e) => {
+			root.delete(e);
+			return e;
+		}).reduce((acc, el) => {
+			if (!acc.some(isAncestor(el))) {
+				acc.push(el);
+				parents.set(el, parent);
+			}
+			return acc;
+		}, []));
+		return acc;
+	}, new import_default_map.default(() => []));
+	return {
+		sorted,
+		byId: (id) => nonNullable(map.get(id), `Element not found by id: ${id}`),
+		root,
+		parent: (el) => parents.get(el),
+		children: (el) => children.get(el),
+		flatten: () => {
+			return new Set([...root, ...sorted.reduce((acc, el) => {
+				const _children = children.get(el);
+				if (_children.length === 0) {
+					acc.push(el);
+					return acc;
+				}
+				if (_children.length > 1) acc.push(..._children);
+				return acc;
+			}, [])]);
+		}
+	};
+}
+
+//#endregion
+//#region src/compute-view/relationships-view/compute.ts
+const finalize = (elements, explicits) => {
+	if (elements.size > 2 && explicits.size !== elements.size) return new Set(sortParentsFirst([...treeFromElements(elements).flatten(), ...explicits]));
+	if (elements.size > 1) return new Set(sortParentsFirst([...elements]));
+	return elements;
+};
+function computeRelationships(subject, others, relationships) {
+	const isOther = (e) => others.has(e);
+	let subjects = new Set([subject]);
+	const explicits = {
+		incomers: /* @__PURE__ */ new Set(),
+		subjects: new Set([subject]),
+		outgoers: /* @__PURE__ */ new Set()
+	};
+	let incomers = new Set(relationships.incoming.flatMap((r) => {
+		explicits.subjects.add(r.target);
+		explicits.incomers.add(r.source);
+		subjects.add(r.target);
+		if (r.target !== subject) {
+			let target = r.target.parent;
+			while (target && target !== subject) {
+				subjects.add(target);
+				target = target.parent;
+			}
+		}
+		let source = r.source;
+		const incomerBranch = [];
+		while (true) {
+			incomerBranch.push(source);
+			if (isOther(source) || !source.parent) break;
+			source = source.parent;
+		}
+		return incomerBranch;
+	}));
+	let outgoers = new Set(relationships.outgoing.flatMap((r) => {
+		explicits.subjects.add(r.source);
+		explicits.outgoers.add(r.target);
+		subjects.add(r.source);
+		if (r.source !== subject) {
+			let source = r.source.parent;
+			while (source && source !== subject) {
+				subjects.add(source);
+				source = source.parent;
+			}
+		}
+		let target = r.target;
+		const outgoerBranch = [];
+		while (true) {
+			outgoerBranch.push(target);
+			if (isOther(target) || !target.parent) break;
+			target = target.parent;
+		}
+		return outgoerBranch;
+	}));
+	return {
+		incomers: finalize(incomers, explicits.incomers),
+		incoming: new Set(relationships.incoming),
+		subjects: finalize(subjects, explicits.subjects),
+		outgoing: new Set(relationships.outgoing),
+		outgoers: finalize(outgoers, explicits.outgoers)
+	};
+}
+function computeRelationshipsView(subjectId, likec4model, scopeViewId, scope = "global") {
+	const view = scopeViewId ? likec4model.findView(scopeViewId) : null;
+	if (scope === "view") {
+		invariant(view, "Scope view id is required when scope is \"view\"");
+		return computeScopedRelationshipsView(subjectId, view, likec4model);
+	}
+	const subject = likec4model.element(subjectId);
+	return computeRelationships(subject, toSet(subject.ascendingSiblings()), {
+		incoming: [...subject.incoming()],
+		outgoing: [...subject.outgoing()]
+	});
+}
+function computeScopedRelationshipsView(subjectId, view, likec4model) {
+	const subject = likec4model.element(subjectId);
+	let relationships = {
+		incoming: toArray(ifilter(subject.incoming(), (r) => view.includesRelation(r.id))),
+		outgoing: toArray(ifilter(subject.outgoing(), (r) => view.includesRelation(r.id)))
+	};
+	const isDescendant = isDescendantOf(subject);
+	return computeRelationships(subject, new Set([...subject.ascendingSiblings(), ...t(view.elements(), imap((e) => e.element), ifilter((e) => e !== subject && isDescendant(e)))]), relationships);
+}
+
+//#endregion
+export { treeFromElements as n, computeRelationshipsView as t };

package/dist/_chunks/rolldown-runtime.mjs

@@ -0,0 +1,42 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+export { __exportAll as n, __toESM as r, __commonJSMin as t };

package/dist/{shared/core.C_3y3eqV.d.mts → _chunks/scalar.d.mts}

@@ -1,13 +1,17 @@
-import { Tagged } from 'type-fest';
+import { Tagged } from "type-fest";
 
+//#region src/types/scalar.d.ts
+declare namespace scalar_d_exports {
+  export { AnyFqn, BuiltInIcon, DeploymentFqn, DeploymentKind, EdgeId, ElementKind, Fqn, GlobalFqn, GroupElementKind, Icon, IconUrl, MarkdownOrString, NodeId, NoneIcon, ProjectId, RelationId, RelationKind, RelationshipKind, StepEdgeId, StepEdgeIdLiteral, StepEdgeKind, Tag, ViewId, extractStep, flattenMarkdownOrString, isGlobalFqn, isGroupElementKind, isStepEdgeId, splitGlobalFqn, stepEdgeId };
+}
 type ProjectId<T = string> = Tagged<T, 'ProjectID'>;
 declare function ProjectId(name: string): ProjectId;
 type MarkdownOrString = {
-    txt: string;
-    md?: never;
+  txt: string;
+  md?: never;
 } | {
-    md: string;
-    txt?: never;
+  md: string;
+  txt?: never;
 };
 /**
  * Converts a MarkdownOrString object or a plain string into a simple string representation.
@@ -66,9 +70,9 @@ type ElementKind<Kinds = string> = Tagged<Kinds, 'ElementKind'>;
 declare const GroupElementKind: ElementKind<"@group">;
 type GroupElementKind = typeof GroupElementKind;
 declare function isGroupElementKind<V extends {
-    kind?: any;
+  kind?: any;
 }>(v: V): v is V & {
-    kind: GroupElementKind;
+  kind: GroupElementKind;
 };
 /**
  * Full-qualified-name for deployment elements
@@ -101,39 +105,5 @@ declare function stepEdgeId(step: number, parallelStep?: number): StepEdgeId;
 declare const StepEdgeKind = "@step";
 declare function isStepEdgeId(id: string): id is StepEdgeId;
 declare function extractStep(id: EdgeId): number;
-
-type scalar_AnyFqn<T = string> = AnyFqn<T>;
-type scalar_BuiltInIcon = BuiltInIcon;
-declare const scalar_DeploymentFqn: typeof DeploymentFqn;
-type scalar_DeploymentKind<Kinds = string> = DeploymentKind<Kinds>;
-declare const scalar_EdgeId: typeof EdgeId;
-type scalar_ElementKind<Kinds = string> = ElementKind<Kinds>;
-declare const scalar_Fqn: typeof Fqn;
-declare const scalar_GlobalFqn: typeof GlobalFqn;
-type scalar_GroupElementKind = GroupElementKind;
-type scalar_Icon = Icon;
-type scalar_IconUrl = IconUrl;
-type scalar_MarkdownOrString = MarkdownOrString;
-declare const scalar_NodeId: typeof NodeId;
-declare const scalar_NoneIcon: typeof NoneIcon;
-declare const scalar_ProjectId: typeof ProjectId;
-declare const scalar_RelationId: typeof RelationId;
-type scalar_RelationKind<Kinds = string> = RelationKind<Kinds>;
-type scalar_RelationshipKind<Kinds = string> = RelationshipKind<Kinds>;
-type scalar_StepEdgeId = StepEdgeId;
-type scalar_StepEdgeIdLiteral = StepEdgeIdLiteral;
-declare const scalar_StepEdgeKind: typeof StepEdgeKind;
-type scalar_Tag<T = string> = Tag<T>;
-declare const scalar_ViewId: typeof ViewId;
-declare const scalar_extractStep: typeof extractStep;
-declare const scalar_flattenMarkdownOrString: typeof flattenMarkdownOrString;
-declare const scalar_isGlobalFqn: typeof isGlobalFqn;
-declare const scalar_isGroupElementKind: typeof isGroupElementKind;
-declare const scalar_isStepEdgeId: typeof isStepEdgeId;
-declare const scalar_splitGlobalFqn: typeof splitGlobalFqn;
-declare const scalar_stepEdgeId: typeof stepEdgeId;
-declare namespace scalar {
-  export { type scalar_AnyFqn as AnyFqn, type scalar_BuiltInIcon as BuiltInIcon, scalar_DeploymentFqn as DeploymentFqn, type scalar_DeploymentKind as DeploymentKind, scalar_EdgeId as EdgeId, type scalar_ElementKind as ElementKind, scalar_Fqn as Fqn, scalar_GlobalFqn as GlobalFqn, type scalar_GroupElementKind as GroupElementKind, type scalar_Icon as Icon, type scalar_IconUrl as IconUrl, type scalar_MarkdownOrString as MarkdownOrString, scalar_NodeId as NodeId, scalar_NoneIcon as NoneIcon, scalar_ProjectId as ProjectId, scalar_RelationId as RelationId, type scalar_RelationKind as RelationKind, type scalar_RelationshipKind as RelationshipKind, type scalar_StepEdgeId as StepEdgeId, type scalar_StepEdgeIdLiteral as StepEdgeIdLiteral, scalar_StepEdgeKind as StepEdgeKind, type scalar_Tag as Tag, scalar_ViewId as ViewId, scalar_extractStep as extractStep, scalar_flattenMarkdownOrString as flattenMarkdownOrString, scalar_isGlobalFqn as isGlobalFqn, scalar_isGroupElementKind as isGroupElementKind, scalar_isStepEdgeId as isStepEdgeId, scalar_splitGlobalFqn as splitGlobalFqn, scalar_stepEdgeId as stepEdgeId };
-}
-
-export { type AnyFqn as A, type BuiltInIcon as B, DeploymentFqn as D, type ElementKind as E, Fqn as F, GroupElementKind as G, type Icon as I, type MarkdownOrString as M, NoneIcon as N, ProjectId as P, type RelationKind as R, type StepEdgeIdLiteral as S, type Tag as T, ViewId as V, type IconUrl as a, type DeploymentKind as b, type RelationshipKind as c, RelationId as d, GlobalFqn as e, flattenMarkdownOrString as f, isGlobalFqn as g, splitGlobalFqn as h, isGroupElementKind as i, NodeId as j, EdgeId as k, type StepEdgeId as l, stepEdgeId as m, StepEdgeKind as n, isStepEdgeId as o, extractStep as p, scalar as s };
+//#endregion
+export { splitGlobalFqn as A, ViewId as C, isGroupElementKind as D, isGlobalFqn as E, isStepEdgeId as O, Tag as S, flattenMarkdownOrString as T, RelationKind as _, EdgeId as a, StepEdgeIdLiteral as b, GlobalFqn as c, IconUrl as d, MarkdownOrString as f, RelationId as g, ProjectId as h, DeploymentKind as i, stepEdgeId as j, scalar_d_exports as k, GroupElementKind as l, NoneIcon as m, BuiltInIcon as n, ElementKind as o, NodeId as p, DeploymentFqn as r, Fqn as s, AnyFqn as t, Icon as u, RelationshipKind as v, extractStep as w, StepEdgeKind as x, StepEdgeId as y };

package/dist/_chunks/scalar.mjs

@@ -0,0 +1,84 @@
+import { n as __exportAll } from "./rolldown-runtime.mjs";
+import { D as e$1, O as e } from "./libs/remeda.mjs";
+import { t as invariant } from "./invariant.mjs";
+
+//#region src/types/scalar.ts
+var scalar_exports = /* @__PURE__ */ __exportAll({
+	DeploymentFqn: () => DeploymentFqn,
+	EdgeId: () => EdgeId,
+	Fqn: () => Fqn,
+	GlobalFqn: () => GlobalFqn,
+	GroupElementKind: () => GroupElementKind,
+	NodeId: () => NodeId,
+	NoneIcon: () => NoneIcon,
+	ProjectId: () => ProjectId,
+	RelationId: () => RelationId,
+	StepEdgeKind: () => StepEdgeKind,
+	ViewId: () => ViewId,
+	extractStep: () => extractStep,
+	flattenMarkdownOrString: () => flattenMarkdownOrString,
+	isGlobalFqn: () => isGlobalFqn,
+	isGroupElementKind: () => isGroupElementKind,
+	isStepEdgeId: () => isStepEdgeId,
+	splitGlobalFqn: () => splitGlobalFqn,
+	stepEdgeId: () => stepEdgeId
+});
+function ProjectId(name) {
+	return name;
+}
+function flattenMarkdownOrString(value) {
+	if (value === null || value === void 0) return null;
+	const content = e(value) ? value : value.txt ?? value.md;
+	return e$1(content?.trim()) ? content : null;
+}
+const NoneIcon = "none";
+function Fqn(name, parent) {
+	return parent ? parent + "." + name : name;
+}
+const GroupElementKind = "@group";
+function isGroupElementKind(v) {
+	return v.kind === GroupElementKind;
+}
+function DeploymentFqn(name, parent) {
+	return parent ? parent + "." + name : name;
+}
+function ViewId(id) {
+	return id;
+}
+function RelationId(id) {
+	return id;
+}
+function GlobalFqn(projectId, name) {
+	invariant(typeof projectId === "string" && projectId != "");
+	return "@" + projectId + "." + name;
+}
+function isGlobalFqn(fqn) {
+	return fqn.startsWith("@");
+}
+function splitGlobalFqn(fqn) {
+	if (!fqn.startsWith("@")) return [null, fqn];
+	const firstDot = fqn.indexOf(".");
+	if (firstDot < 2) throw new Error("Invalid global FQN");
+	return [fqn.slice(1, firstDot), fqn.slice(firstDot + 1)];
+}
+function NodeId(id) {
+	return id;
+}
+function EdgeId(id) {
+	return id;
+}
+function stepEdgeId(step, parallelStep) {
+	const id = `step-${String(step).padStart(2, "0")}`;
+	return parallelStep ? `${id}.${parallelStep}` : id;
+}
+const StepEdgeKind = "@step";
+function isStepEdgeId(id) {
+	return id.startsWith("step-");
+}
+function extractStep(id) {
+	if (!isStepEdgeId(id)) throw new Error(`Invalid step edge id: ${id}`);
+	return parseFloat(id.slice(5));
+}
+
+//#endregion
+export { scalar_exports as _, GroupElementKind as a, ProjectId as c, ViewId as d, extractStep as f, isStepEdgeId as g, isGroupElementKind as h, GlobalFqn as i, RelationId as l, isGlobalFqn as m, EdgeId as n, NodeId as o, flattenMarkdownOrString as p, Fqn as r, NoneIcon as s, DeploymentFqn as t, StepEdgeKind as u, splitGlobalFqn as v, stepEdgeId as y };