@likec4/core 1.48.0 → 1.50.0

package/dist/_chunks/find2.d.mts

@@ -1,78 +0,0 @@
-import { G as Unknown, f as EdgeId, n as Any } from "./_aux.mjs";
-import { C as ElementModel, T as RelationshipModel } from "./LikeC4Model.mjs";
-import { n as Connection, t as customInspectSymbol } from "./const.mjs";
-
-//#region src/model/connection/model/ConnectionModel.d.ts
-/**
- * Connection refers to any relationships between two elements,
- * both direct and implicit ones (between their nested elements).
- *
- * Merges relationships together to an single edge on the diagram.
- */
-declare class ConnectionModel<A extends Any = Unknown> implements Connection<ElementModel<A>, EdgeId> {
-  readonly source: ElementModel<A>;
-  readonly target: ElementModel<A>;
-  readonly relations: ReadonlySet<RelationshipModel<A>>;
-  readonly id: EdgeId;
-  constructor(source: ElementModel<A>, target: ElementModel<A>, relations?: ReadonlySet<RelationshipModel<A>>);
-  private _boundary;
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
-   */
-  get boundary(): ElementModel<A> | null;
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  get expression(): string;
-  /**
-   * Returns true if only includes relations between the source and target elements.
-   */
-  get isDirect(): boolean;
-  /**
-   * Returns true if includes relations between nested elements of the source and target elements.
-   */
-  get isImplicit(): boolean;
-  get directRelations(): ReadonlySet<RelationshipModel<A>>;
-  nonEmpty(): boolean;
-  mergeWith(other: ConnectionModel<A>): ConnectionModel<A>;
-  difference(other: ConnectionModel<A>): ConnectionModel<A>;
-  intersect(other: ConnectionModel<A>): ConnectionModel<A>;
-  equals(other: Connection): boolean;
-  /**
-   * Returns a new instance with the updated relations.
-   *
-   * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
-   * @returns A new `ConnectionModel` instance with the updated relations.
-   */
-  update(relations: ReadonlySet<RelationshipModel<A>>): ConnectionModel<A>;
-  [customInspectSymbol](_depth: any, _inspectOptions: any, _inspect: any): string;
-  toString(): string;
-  /**
-   * Creates a new connection with reversed direction (target becomes source and vice versa)
-   */
-  reversed(): ConnectionModel<A>;
-}
-declare namespace find_d_exports {
-  export { findConnection, findConnectionsBetween, findConnectionsWithin };
-}
-/**
- * Resolve connection from source to target
- *
- * @param direction - if 'both', also returns connection from target to source
- * @default `directed`
- */
-declare function findConnection<A extends Any>(source: ElementModel<A>, target: ElementModel<A>, direction?: 'directed' | 'both'): [ConnectionModel<A>, ConnectionModel<A>] | [ConnectionModel<A>] | [];
-/**
- * Resolve all connections between element and others
- * @param direction - if 'directed', only look for outgoing connections from the element to others
- * @default `both`
- */
-declare function findConnectionsBetween<M extends Any>(element: ElementModel<M>, others: Iterable<ElementModel<M>>, direction?: 'directed' | 'both'): readonly ConnectionModel<M>[];
-/**
- * Resolve all connections within a given set of elements
- */
-declare function findConnectionsWithin<M extends Any>(elements: Iterable<ElementModel<M>>): readonly ConnectionModel<M>[];
-//#endregion
-export { ConnectionModel as a, find_d_exports as i, findConnectionsBetween as n, findConnectionsWithin as r, findConnection as t };

package/dist/_chunks/find2.mjs

@@ -1,287 +0,0 @@
-import { n as __exportAll } from "./rolldown-runtime.mjs";
-import { M as e, Q as t, w as t$1 } from "./libs/remeda.mjs";
-import { C as isAncestor, P as isString, T as isSameHierarchy, a as difference, c as intersection, k as sortNaturalByFqn, o as equals, r as stringHash, u as union, w as isDescendantOf } from "./utils.mjs";
-import { t as invariant } from "./invariant.mjs";
-import { f as ifilter, i as isome } from "./iterable.mjs";
-import { t as customInspectSymbol } from "./const.mjs";
-
-//#region src/model/connection/ops.ts
-function isNestedConnection(nested, parent) {
-	if (!parent) {
-		const p = nested;
-		return (n) => isNestedConnection(n, p);
-	}
-	const isSameSource = nested.source === parent.source;
-	const isSameTarget = nested.target === parent.target;
-	if (isSameSource && isSameTarget) return false;
-	const isSourceNested = isAncestor(parent.source.id, nested.source.id);
-	const isTargetNested = isAncestor(parent.target.id, nested.target.id);
-	return isSourceNested && isTargetNested || isSameSource && isTargetNested || isSameTarget && isSourceNested;
-}
-function findDeepestNestedConnection(connections, connection) {
-	let deepest = connection;
-	for (const c of connections) if (isNestedConnection(c, deepest)) deepest = c;
-	return deepest !== connection ? deepest : null;
-}
-function sortDeepestFirst(connections) {
-	const sorted = [];
-	const unsorted = connections.slice();
-	let next;
-	while (next = unsorted.shift()) {
-		let deepest;
-		while (deepest = findDeepestNestedConnection(unsorted, next)) {
-			const index = unsorted.indexOf(deepest);
-			sorted.push(unsorted.splice(index, 1)[0]);
-		}
-		sorted.push(next);
-	}
-	return sorted;
-}
-/**
-* To make {@link sortConnectionsByBoundaryHierarchy} work correctly we add '.' to boundary
-* Othwerwise connection without boundary will be considered same level as connection with top-level boundary
-*/
-function boundaryHierarchy(conn) {
-	return conn.boundary?.id ? `.${conn.boundary.id}` : "";
-}
-function sortConnectionsByBoundaryHierarchy(connections, sort) {
-	if (!connections || isString(connections)) {
-		const dir = connections ?? "asc";
-		return (arr) => _sortByBoundary(arr, dir);
-	}
-	return _sortByBoundary(connections, sort ?? "asc");
-}
-function _sortByBoundary(connections, order) {
-	return t(connections, t$1((conn) => ({
-		id: boundaryHierarchy(conn),
-		conn
-	})), sortNaturalByFqn(order), t$1((p) => p.conn));
-}
-/**
-* Find connections that includes given connection (i.e between it's ancestors)
-*/
-function findAscendingConnections(connections, connection) {
-	return connections.filter((c) => isNestedConnection(connection, c));
-}
-/**
-* Find connections that given connection includes (i.e between it's descendants)
-*/
-function findDescendantConnections(connections, connection) {
-	return connections.filter(isNestedConnection(connection));
-}
-function mergeConnections(connections) {
-	const map = /* @__PURE__ */ new Map();
-	for (const conn of connections) {
-		const existing = map.get(conn.id);
-		if (existing) map.set(conn.id, conn.mergeWith(existing));
-		else map.set(conn.id, conn);
-	}
-	return [...map.values()];
-}
-/**
-* Excludes the values existing in `other` array.
-* The output maintains the same order as the input.
-*/
-function differenceConnections(source, exclude) {
-	const minus = new Map([...exclude].map((c) => [c.id, c]));
-	return [...source].reduce((acc, c) => {
-		const other = minus.get(c.id);
-		if (!other) {
-			acc.push(c);
-			return acc;
-		}
-		const updated = c.difference(other);
-		if (updated.nonEmpty()) acc.push(updated);
-		return acc;
-	}, []);
-}
-function hasSameSourceTarget(a, b) {
-	if (b) return a.source === b.source && a.target === b.target;
-	return (b) => a.source === b.source && a.target === b.target;
-}
-function hasSameSource(a, b) {
-	if (b) return a.source === b.source;
-	return (b) => a.source === b.source;
-}
-function hasSameTarget(a, b) {
-	if (b) return a.target === b.target;
-	return (b) => a.target === b.target;
-}
-function isOutgoing(a, source) {
-	if (!source) {
-		const _source = a;
-		return (b) => isOutgoing(b, _source);
-	}
-	const at = a;
-	return isDescendantOf(at.source, source) && !isDescendantOf(at.target, source);
-}
-function isIncoming(a, target) {
-	if (!target) {
-		const _target = a;
-		return (b) => isIncoming(b, _target);
-	}
-	const at = a;
-	return isDescendantOf(at.target, target) && !isDescendantOf(at.source, target);
-}
-function isAnyInOut(a, source) {
-	if (!source) {
-		const _source = a;
-		return (b) => isAnyInOut(b, _source);
-	}
-	const at = a;
-	return isDescendantOf(at.source, source) !== isDescendantOf(at.target, source);
-}
-
-//#endregion
-//#region src/model/connection/model/ConnectionModel.ts
-/**
-* Connection refers to any relationships between two elements,
-* both direct and implicit ones (between their nested elements).
-*
-* Merges relationships together to an single edge on the diagram.
-*/
-var ConnectionModel = class ConnectionModel {
-	id;
-	constructor(source, target, relations = /* @__PURE__ */ new Set()) {
-		this.source = source;
-		this.target = target;
-		this.relations = relations;
-		this.id = stringHash(`model:${source.id}:${target.id}`);
-	}
-	_boundary;
-	/**
-	* Common ancestor of the source and target elements.
-	* Represents the boundary of the connection.
-	*/
-	get boundary() {
-		return this._boundary ??= this.source.commonAncestor(this.target);
-	}
-	/**
-	* Human readable expression of the connection
-	* Mostly used for testing and debugging
-	*/
-	get expression() {
-		return `${this.source.id} -> ${this.target.id}`;
-	}
-	/**
-	* Returns true if only includes relations between the source and target elements.
-	*/
-	get isDirect() {
-		return this.nonEmpty() && !this.isImplicit;
-	}
-	/**
-	* Returns true if includes relations between nested elements of the source and target elements.
-	*/
-	get isImplicit() {
-		return this.nonEmpty() && isome(this.relations, e(hasSameSourceTarget(this)));
-	}
-	get directRelations() {
-		return new Set(ifilter(this.relations, hasSameSourceTarget(this)));
-	}
-	nonEmpty() {
-		return this.relations.size > 0;
-	}
-	mergeWith(other) {
-		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 ConnectionModel(this.source, this.target, union(this.relations, other.relations));
-	}
-	difference(other) {
-		return new ConnectionModel(this.source, this.target, difference(this.relations, other.relations));
-	}
-	intersect(other) {
-		invariant(other instanceof ConnectionModel, "Cannot intersect connection with different type");
-		return new ConnectionModel(this.source, this.target, intersection(this.relations, other.relations));
-	}
-	equals(other) {
-		invariant(other instanceof ConnectionModel, "Cannot merge connection with different type");
-		const _other = other;
-		return this.id === _other.id && this.source.id === _other.source.id && this.target.id === _other.target.id && equals(this.relations, _other.relations);
-	}
-	/**
-	* Returns a new instance with the updated relations.
-	*
-	* @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
-	* @returns A new `ConnectionModel` instance with the updated relations.
-	*/
-	update(relations) {
-		return new ConnectionModel(this.source, this.target, relations);
-	}
-	[customInspectSymbol](_depth, _inspectOptions, _inspect) {
-		const asString = this.toString();
-		Object.defineProperty(asString, "constructor", {
-			value: ConnectionModel,
-			enumerable: false
-		});
-		return asString;
-	}
-	toString() {
-		return [
-			this.expression,
-			this.relations.size ? "  relations:" : "  relations: [ ]",
-			...[...this.relations].map((c) => "    " + c.expression)
-		].join("\n");
-	}
-	/**
-	* Creates a new connection with reversed direction (target becomes source and vice versa)
-	*/
-	reversed() {
-		return new ConnectionModel(this.target, this.source);
-	}
-};
-
-//#endregion
-//#region src/model/connection/model/find.ts
-var find_exports = /* @__PURE__ */ __exportAll({
-	findConnection: () => findConnection,
-	findConnectionsBetween: () => findConnectionsBetween,
-	findConnectionsWithin: () => findConnectionsWithin
-});
-/**
-* Resolve connection from source to target
-*
-* @param direction - if 'both', also returns connection from target to source
-* @default `directed`
-*/
-function findConnection(source, target, direction = "directed") {
-	if (source === target) return [];
-	if (isSameHierarchy(source, target)) return [];
-	const directedIntersection = intersection(source.allOutgoing, target.allIncoming);
-	const directed = directedIntersection.size > 0 ? new ConnectionModel(source, target, directedIntersection) : null;
-	if (direction === "directed") return directed ? [directed] : [];
-	const reverseIntersection = intersection(source.allIncoming, target.allOutgoing);
-	const reverse = reverseIntersection.size > 0 ? new ConnectionModel(target, source, reverseIntersection) : null;
-	if (directed && reverse) return [directed, reverse];
-	if (directed) return [directed];
-	if (reverse) return [reverse];
-	return [];
-}
-/**
-* Resolve all connections between element and others
-* @param direction - if 'directed', only look for outgoing connections from the element to others
-* @default `both`
-*/
-function findConnectionsBetween(element, others, direction = "both") {
-	if (element.allIncoming.size === 0 && element.allOutgoing.size === 0) 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 { mergeConnections as _, ConnectionModel as a, findDeepestNestedConnection as c, hasSameSourceTarget as d, hasSameTarget as f, isOutgoing as g, isNestedConnection as h, find_exports as i, findDescendantConnections as l, isIncoming as m, findConnectionsBetween as n, differenceConnections as o, isAnyInOut as p, findConnectionsWithin as r, findAscendingConnections as s, findConnection as t, hasSameSource as u, sortConnectionsByBoundaryHierarchy as v, sortDeepestFirst as y };

package/dist/_chunks/fqnRef.d.mts

@@ -1,58 +0,0 @@
-import { h as Fqn, j as ProjectId, n as Any, p as ElementId, u as DeploymentId, vt as ExclusiveUnion } from "./_aux.mjs";
-
-//#region src/types/fqnRef.d.ts
-type AnyAux = Any;
-declare namespace FqnRef {
-  /**
-   * Reference to logical model element
-   */
-  interface ElementRef<A extends AnyAux = AnyAux> {
-    project?: never;
-    model: ElementId<A>;
-  }
-  function isElementRef<A extends AnyAux>(ref: FqnRef<A>): ref is ElementRef<A>;
-  /**
-   * Reference to imported logical model element
-   */
-  interface ImportRef<A extends AnyAux = AnyAux> {
-    project: ProjectId<A>;
-    model: ElementId<A>;
-  }
-  function isImportRef<A extends AnyAux>(ref: FqnRef<A>): ref is ImportRef<A>;
-  function flatten<A extends AnyAux>(ref: FqnRef<A>): Fqn<A>;
-  type ModelRef<A extends AnyAux = AnyAux> = ImportRef<A> | ElementRef<A>;
-  function isModelRef<A extends AnyAux>(ref: FqnRef<A>): ref is ModelRef<A>;
-  /**
-   * Represents a reference to an instance within a deployment.
-   *
-   * @template D - The type representing the deployment fqn. Defaults to `Fqn`.
-   * @template M - The type representing the model fqn. Defaults to `Fqn`.
-   *
-   * @property {D} deployment - TThe fully qualified name (FQN) of the deployed instance.
-   * @property {M} element - The element reference within the deployment.
-   */
-  interface InsideInstanceRef<A extends AnyAux = AnyAux> {
-    deployment: DeploymentId<A>;
-    element: ElementId<A>;
-  }
-  function isInsideInstanceRef<A extends AnyAux>(ref: FqnRef<A>): ref is InsideInstanceRef<A>;
-  /**
-   * Represents a reference to a deployment element.
-   *
-   * @template F - The type of the fully qualified name (FQN) of the deployment element. Defaults to `Fqn`.
-   * @property {F} deployment - The fully qualified name (FQN) of the deployment element.
-   */
-  interface DeploymentElementRef<A extends AnyAux> {
-    deployment: DeploymentId<A>;
-    element?: never;
-  }
-  function isDeploymentElementRef<A extends AnyAux>(ref: FqnRef<A>): ref is DeploymentElementRef<A>;
-  type DeploymentRef<A extends AnyAux> = DeploymentElementRef<A> | InsideInstanceRef<A>;
-  function isDeploymentRef<A extends AnyAux>(ref: FqnRef<A>): ref is DeploymentRef<A>;
-}
-type FqnRef<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-  DeploymentRef: FqnRef.DeploymentRef<A>;
-  ModelRef: FqnRef.ModelRef<A>;
-}>;
-//#endregion
-export { FqnRef as t };

package/dist/_chunks/fqnRef.mjs

@@ -1,41 +0,0 @@
-import { O as e } from "./libs/remeda.mjs";
-import { i as GlobalFqn } from "./scalar.mjs";
-
-//#region src/types/fqnRef.ts
-let FqnRef;
-(function(_FqnRef) {
-	function isElementRef(ref) {
-		return "model" in ref && !("project" in ref);
-	}
-	_FqnRef.isElementRef = isElementRef;
-	function isImportRef(ref) {
-		return "project" in ref && "model" in ref;
-	}
-	_FqnRef.isImportRef = isImportRef;
-	function flatten(ref) {
-		if (e(ref)) throw new Error(`Expected FqnRef, got: "${ref}"`);
-		if (isImportRef(ref)) return GlobalFqn(ref.project, ref.model);
-		if (isElementRef(ref)) return ref.model;
-		throw new Error("Expected FqnRef.ModelRef or FqnRef.ImportRef");
-	}
-	_FqnRef.flatten = flatten;
-	function isModelRef(ref) {
-		return isElementRef(ref) || isImportRef(ref);
-	}
-	_FqnRef.isModelRef = isModelRef;
-	function isInsideInstanceRef(ref) {
-		return "deployment" in ref && "element" in ref;
-	}
-	_FqnRef.isInsideInstanceRef = isInsideInstanceRef;
-	function isDeploymentElementRef(ref) {
-		return "deployment" in ref && !("element" in ref);
-	}
-	_FqnRef.isDeploymentElementRef = isDeploymentElementRef;
-	function isDeploymentRef(ref) {
-		return isDeploymentElementRef(ref) || isInsideInstanceRef(ref);
-	}
-	_FqnRef.isDeploymentRef = isDeploymentRef;
-})(FqnRef || (FqnRef = {}));
-
-//#endregion
-export { FqnRef as t };

package/dist/_chunks/index6.d.mts

@@ -1,43 +0,0 @@
-import { G as Unknown, Y as ViewId, n as Any, p as ElementId } from "./_aux.mjs";
-import { C as ElementModel, T as RelationshipModel, n as LikeC4Model } from "./LikeC4Model.mjs";
-
-//#region src/compute-view/relationships-view/_types.d.ts
-type RelationshipsViewData<M extends Any = Unknown> = {
-  incomers: ReadonlySet<ElementModel<M>>;
-  incoming: ReadonlySet<RelationshipModel<M>>;
-  subjects: ReadonlySet<ElementModel<M>>;
-  outgoing: ReadonlySet<RelationshipModel<M>>;
-  outgoers: ReadonlySet<ElementModel<M>>;
-};
-//#endregion
-//#region src/compute-view/relationships-view/compute.d.ts
-declare function computeRelationshipsView<M extends Any>(subjectId: ElementId<M>, likec4model: LikeC4Model<M>, scopeViewId: ViewId<M> | null, scope?: 'global' | 'view'): RelationshipsViewData<M>;
-//#endregion
-//#region src/compute-view/relationships-view/utils.d.ts
-declare function treeFromElements<M extends Any>(elements: Iterable<ElementModel<M>>): {
-  sorted: readonly ElementModel<M>[];
-  byId: (id: ElementId<M>) => ElementModel<M>;
-  root: ReadonlySet<ElementModel<M>>;
-  parent: (el: ElementModel<M>) => ElementModel<M> | null;
-  children: (el: ElementModel<M>) => ReadonlyArray<ElementModel<M>>;
-  /**
-   * Flattens the tree structure by removing redundant hierarchy levels.
-   * @example
-   *   A
-   *   └── B
-   *       ├── C
-   *       │   └── D
-   *       │       └── E
-   *       └── F
-   *           └── G
-   * becomes
-   *   A
-   *   ├── C
-   *   │   └── E
-   *   └── F
-   *       └── G
-   */
-  flatten: () => Set<ElementModel<M>>;
-};
-//#endregion
-export { computeRelationshipsView as n, RelationshipsViewData as r, treeFromElements as t };