@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/expression.mjs

@@ -0,0 +1,107 @@
+import { t as FqnRef } from "./fqnRef.mjs";
+
+//#region src/types/expression.ts
+let FqnExpr;
+(function(_FqnExpr) {
+	function isWildcard(expr) {
+		return "wildcard" in expr && expr.wildcard === true;
+	}
+	_FqnExpr.isWildcard = isWildcard;
+	function isModelRef(ref) {
+		return "ref" in ref && FqnRef.isModelRef(ref.ref);
+	}
+	_FqnExpr.isModelRef = isModelRef;
+	function isDeploymentRef(expr) {
+		return "ref" in expr && FqnRef.isDeploymentRef(expr.ref);
+	}
+	_FqnExpr.isDeploymentRef = isDeploymentRef;
+	function isElementKindExpr(expr) {
+		return "elementKind" in expr && "isEqual" in expr;
+	}
+	_FqnExpr.isElementKindExpr = isElementKindExpr;
+	function isElementTagExpr(expr) {
+		return "elementTag" in expr && "isEqual" in expr;
+	}
+	_FqnExpr.isElementTagExpr = isElementTagExpr;
+	function isWhere(expr) {
+		return "where" in expr && is(expr.where.expr);
+	}
+	_FqnExpr.isWhere = isWhere;
+	function isCustom(expr) {
+		return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
+	}
+	_FqnExpr.isCustom = isCustom;
+	function is(expr) {
+		return isWildcard(expr) || isModelRef(expr) || isDeploymentRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+	}
+	_FqnExpr.is = is;
+	function unwrap(expr) {
+		if (isCustom(expr)) expr = expr.custom.expr;
+		if (isWhere(expr)) expr = expr.where.expr;
+		return expr;
+	}
+	_FqnExpr.unwrap = unwrap;
+})(FqnExpr || (FqnExpr = {}));
+let RelationExpr;
+(function(_RelationExpr) {
+	function isDirect(expr) {
+		return "source" in expr && "target" in expr;
+	}
+	_RelationExpr.isDirect = isDirect;
+	function isIncoming(expr) {
+		return "incoming" in expr;
+	}
+	_RelationExpr.isIncoming = isIncoming;
+	function isOutgoing(expr) {
+		return "outgoing" in expr;
+	}
+	_RelationExpr.isOutgoing = isOutgoing;
+	function isInOut(expr) {
+		return "inout" in expr;
+	}
+	_RelationExpr.isInOut = isInOut;
+	function isWhere(expr) {
+		return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
+	}
+	_RelationExpr.isWhere = isWhere;
+	function isCustom(expr) {
+		return "customRelation" in expr;
+	}
+	_RelationExpr.isCustom = isCustom;
+	function is(expr) {
+		return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
+	}
+	_RelationExpr.is = is;
+	function unwrap(expr) {
+		if (isCustom(expr)) expr = expr.customRelation.expr;
+		if (isWhere(expr)) expr = expr.where.expr;
+		return expr;
+	}
+	_RelationExpr.unwrap = unwrap;
+})(RelationExpr || (RelationExpr = {}));
+let Expression;
+(function(_Expression) {
+	function isWhere(expr) {
+		return "where" in expr;
+	}
+	_Expression.isWhere = isWhere;
+	function isRelationWhere(expr) {
+		return RelationExpr.isWhere(expr);
+	}
+	_Expression.isRelationWhere = isRelationWhere;
+	function isFqnExprWhere(expr) {
+		return FqnExpr.isWhere(expr);
+	}
+	_Expression.isFqnExprWhere = isFqnExprWhere;
+	function isFqnExpr(expr) {
+		return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr);
+	}
+	_Expression.isFqnExpr = isFqnExpr;
+	function isRelation(expr) {
+		return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr);
+	}
+	_Expression.isRelation = isRelation;
+})(Expression || (Expression = {}));
+
+//#endregion
+export { FqnExpr as n, RelationExpr as r, Expression as t };

package/dist/_chunks/find.d.mts

@@ -0,0 +1,82 @@
+import { bt as IteratorLike, f as EdgeId, n as Any } from "./_aux.mjs";
+import { T as RelationshipModel, a as DeploymentNodeModel, i as DeploymentElementModel, l as RelationshipsAccum, s as DeploymentRelationModel } from "./LikeC4Model.mjs";
+import { n as Connection, t as customInspectSymbol } from "./const.mjs";
+
+//#region src/model/connection/deployment/DeploymentConnectionModel.d.ts
+/**
+ * Connection is ephemeral entity, result of a resolving relationships between source and target.
+ * Includes direct relationships and/or between their nested elements.
+ */
+declare class DeploymentConnectionModel<A extends Any = Any> implements Connection<DeploymentElementModel<A>, EdgeId> {
+  readonly source: DeploymentElementModel<A>;
+  readonly target: DeploymentElementModel<A>;
+  readonly relations: RelationshipsAccum<A>;
+  readonly id: EdgeId;
+  constructor(source: DeploymentElementModel<A>, target: DeploymentElementModel<A>, relations: RelationshipsAccum<A>);
+  /**
+   * Human readable expression of the connection
+   * Mostly used for testing and debugging
+   */
+  get expression(): string;
+  private _boundary;
+  /**
+   * Common ancestor of the source and target elements.
+   * Represents the boundary of the connection.
+   */
+  get boundary(): DeploymentNodeModel<A> | null;
+  nonEmpty(): boolean;
+  [customInspectSymbol](_depth: any, _inspectOptions: any, _inspect: any): string;
+  toString(): string;
+  /**
+   * Check if connection contains deployment relation,
+   * that is directly connected to source or target.
+   */
+  hasDirectDeploymentRelation(): boolean;
+  values(): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
+  /**
+   * Merge with another connections, if it has the same source and target.
+   * Returns new connection with union of relationships.
+   */
+  mergeWith(others: DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A>;
+  /**
+   * Merge with another connection, if it has the same source and target.
+   * Returns new connection with union of relationships.
+   */
+  mergeWith(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+  difference(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+  intersect(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+  equals(other: Connection): boolean;
+  /**
+   * 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?: {
+    model?: ReadonlySet<RelationshipModel<A>> | null;
+    deployment?: ReadonlySet<DeploymentRelationModel<A>> | null;
+  }): DeploymentConnectionModel<A>;
+}
+declare namespace find_d_exports {
+  export { findConnection, findConnectionsBetween, findConnectionsWithin };
+}
+/**
+ * Resolve connection from source to target
+ * If direction is `both`, also look for reverse connection
+ *
+ * @default direction directed
+ */
+declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'directed'): readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction?: 'directed' | 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+/**
+ * Resolve all connections between element and others
+ * By default, look for both directions.
+ *
+ * @default direction both
+ */
+declare function findConnectionsBetween<M extends Any>(element: DeploymentElementModel<M>, others: Iterable<DeploymentElementModel<NoInfer<M>>>, direction?: 'directed' | 'both'): readonly DeploymentConnectionModel<M>[];
+/**
+ * Resolve all connections within a given set of elements
+ */
+declare function findConnectionsWithin<M extends Any>(elements: Iterable<DeploymentElementModel<M>>): readonly DeploymentConnectionModel<M>[];
+//#endregion
+export { DeploymentConnectionModel as a, find_d_exports as i, findConnectionsBetween as n, findConnectionsWithin as r, findConnection as t };