likec4 1.19.0 → 1.19.1

package/dist/model/index.cjs

@@ -0,0 +1 @@
+"use strict";const index_DafVOuVd=require("../shared/likec4.D81G5JV4.cjs");function createLikeC4Model(e){return index_DafVOuVd.j.create(e)}Object.defineProperty(exports,"ComputedNode",{enumerable:!0,get:function(){return index_DafVOuVd.h}}),Object.defineProperty(exports,"ComputedView",{enumerable:!0,get:function(){return index_DafVOuVd.v}}),Object.defineProperty(exports,"Connection",{enumerable:!0,get:function(){return index_DafVOuVd.a}}),exports.ConnectionModel=index_DafVOuVd.Z,exports.DeployedInstanceModel=index_DafVOuVd.$,exports.DeploymentConnectionModel=index_DafVOuVd.G,exports.DeploymentNodeModel=index_DafVOuVd._,exports.DeploymentRelationModel=index_DafVOuVd.f,Object.defineProperty(exports,"DiagramNode",{enumerable:!0,get:function(){return index_DafVOuVd.W}}),exports.EdgeModel=index_DafVOuVd.T,exports.ElementModel=index_DafVOuVd.m,exports.LikeC4DeploymentModel=index_DafVOuVd.M,exports.LikeC4Model=index_DafVOuVd.j,exports.LikeC4ViewModel=index_DafVOuVd.P,exports.NodeModel=index_DafVOuVd.z,exports.RelationshipModel=index_DafVOuVd.L,exports.deploymentConnection=index_DafVOuVd.R,exports.differenceConnections=index_DafVOuVd.b,exports.findAscendingConnections=index_DafVOuVd.c,exports.findDeepestNestedConnection=index_DafVOuVd.I,exports.findDescendantConnections=index_DafVOuVd.y,exports.hasSameSource=index_DafVOuVd.A,exports.hasSameSourceTarget=index_DafVOuVd.d,exports.hasSameTarget=index_DafVOuVd.O,exports.isAnyInOut=index_DafVOuVd.F,exports.isIncoming=index_DafVOuVd.e,exports.isNestedConnection=index_DafVOuVd.o,exports.isOutgoing=index_DafVOuVd.D,exports.mergeConnections=index_DafVOuVd.s,exports.modelConnection=index_DafVOuVd.C,exports.sortConnectionsByBoundaryHierarchy=index_DafVOuVd.p,exports.sortDeepestFirst=index_DafVOuVd.g,exports.createLikeC4Model=createLikeC4Model;

package/dist/model/index.d.cts

@@ -0,0 +1,258 @@
+import { E as ElementModel, D as DeploymentElementModel, F as Fqn, A as AnyAux, a as DeploymentNodeModel, b as DeployedInstanceModel, R as RelationshipsAccum, I as IteratorLike, c as RelationshipModel, d as DeploymentRelationModel, L as LikeC4Model } from '../shared/likec4.DCwaTTuF.cjs';
+export { k as AbstractRelation, l as AutoLayoutDirection, e as Aux, B as BBox, m as Color, n as ComputedDeploymentView, o as ComputedDynamicView, p as ComputedEdge, q as ComputedElementView, r as ComputedLikeC4Model, C as ComputedNode, i as ComputedView, s as DeployedInstance, t as DeploymentElement, u as DeploymentNode, v as DeploymentNodeKind, w as DeploymentRelation, x as DeploymentView, y as DiagramEdge, j as DiagramNode, z as DiagramView, G as DynamicView, H as EdgeId, f as EdgeModel, J as Element, K as ElementKind, M as ElementView, O as HexColorLiteral, P as LayoutedLikeC4Model, g as LikeC4DeploymentModel, Q as LikeC4View, h as LikeC4ViewModel, S as NodeId, N as NodeModel, T as OverviewGraph, U as ParsedLikeC4Model, V as Point, W as RelationExpr, X as RelationId, Y as StepEdgeId, Z as Tag, _ as ThemeColor, $ as ViewId, a0 as WhereOperator, a1 as XYPoint } from '../shared/likec4.DCwaTTuF.cjs';
+import 'type-fest';
+
+type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+type ReorderedArray<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+
+interface Connection<Elem = ElementModel | DeploymentElementModel, Id = string> {
+    readonly id: Id;
+    readonly source: Elem;
+    readonly target: Elem;
+    /**
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the connection.
+     */
+    readonly boundary: Elem | null;
+    /**
+     * Human readable expression of the connection
+     * Mostly used for testing and debugging
+     */
+    readonly expression: string;
+    mergeWith(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    nonEmpty(): boolean;
+    difference(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    intersect(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    equals(other: Connection): boolean;
+}
+declare namespace Connection {
+    type ConnectionPredicate = <C extends Connection<{
+        id: string;
+    }, any>>(connection: C) => boolean;
+    type ElementId = Fqn | string;
+    export const isInside: (fqn: ElementId) => ConnectionPredicate;
+    export const isDirectedBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
+    export const isAnyBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
+    export const isIncoming: (target: ElementId) => ConnectionPredicate;
+    export const isOutgoing: (source: ElementId) => ConnectionPredicate;
+    export const isAnyInOut: (source: ElementId) => ConnectionPredicate;
+    export {  };
+}
+
+declare const customInspectSymbol: unique symbol;
+
+/**
+ * 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<M extends AnyAux = AnyAux> implements Connection<DeploymentElementModel<M>, M['EdgeId']> {
+    readonly source: DeploymentNodeModel<M> | DeployedInstanceModel<M>;
+    readonly target: DeploymentNodeModel<M> | DeployedInstanceModel<M>;
+    readonly relations: RelationshipsAccum<M>;
+    constructor(source: DeploymentNodeModel<M> | DeployedInstanceModel<M>, target: DeploymentNodeModel<M> | DeployedInstanceModel<M>, relations: RelationshipsAccum<M>);
+    readonly id: M['EdgeId'];
+    /**
+     * 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<M> | 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<M> | DeploymentRelationModel<M>>;
+    /**
+     * Merge with another connection, if it has the same source and target.
+     * Returns new connection with union of relationships.
+     */
+    mergeWith(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
+    difference(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
+    intersect(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
+    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<M>> | null;
+        deployment?: ReadonlySet<DeploymentRelationModel<M>> | null;
+    }): DeploymentConnectionModel<M>;
+}
+
+/**
+ * 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<M extends AnyAux = AnyAux> implements Connection<ElementModel<M>, M['EdgeId']> {
+    readonly source: ElementModel<M>;
+    readonly target: ElementModel<M>;
+    readonly relations: ReadonlySet<RelationshipModel<M>>;
+    readonly id: M['EdgeId'];
+    constructor(source: ElementModel<M>, target: ElementModel<M>, relations?: ReadonlySet<RelationshipModel<M>>);
+    private _boundary;
+    /**
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the connection.
+     */
+    get boundary(): ElementModel<M> | 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<M>>;
+    nonEmpty(): boolean;
+    mergeWith(other: ConnectionModel<M>): ConnectionModel<M>;
+    difference(other: ConnectionModel<M>): ConnectionModel<M>;
+    intersect(other: ConnectionModel<M>): ConnectionModel<M>;
+    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<M>>): ConnectionModel<M>;
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+    toString(): string;
+    /**
+     * Creates a new connection with reversed direction (target becomes source and vice versa)
+     * @param search - When true, attempts to find an existing connection between the reversed nodes
+     */
+    reversed(search?: boolean): ConnectionModel<M>;
+}
+
+/**
+ * Check if connection is nested inside another connection
+ * (i.e. between descendants)
+ */
+declare function isNestedConnection<T extends {
+    id: string;
+}>(parent: WithSourceTarget<NoInfer<T>>): (nested: WithSourceTarget<T>) => boolean;
+declare function isNestedConnection<T extends {
+    id: string;
+}>(nested: WithSourceTarget<T>, parent: WithSourceTarget<T>): boolean;
+type ConnectionElemId = Connection<{
+    readonly id: string;
+}, any>;
+declare function findDeepestNestedConnection<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): C | null;
+declare function sortDeepestFirst<C extends ConnectionElemId>(connections: ReadonlyArray<C>): C[];
+type WithBoundary = {
+    boundary: null | {
+        id: string;
+    };
+};
+declare function sortConnectionsByBoundaryHierarchy(sort?: 'asc' | 'desc'): <T extends WithBoundary, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>;
+declare function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(array: A, sort?: 'asc' | 'desc'): ReorderedArray<A>;
+/**
+ * Find connections that includes given connection (i.e between it's ancestors)
+ */
+declare function findAscendingConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
+/**
+ * Find connections that includes given connection (i.e between it's descendants)
+ */
+declare function findDescendantConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
+declare function mergeConnections<C extends Connection>(connections: ReadonlyArray<C>): C[];
+/**
+ * Excludes the values existing in `other` array.
+ * The output maintains the same order as the input.
+ */
+declare function differenceConnections<C extends Connection>(source: Iterable<C>, exclude: Iterable<C>): C[];
+type WithSourceTarget<T = unknown> = {
+    source: T;
+    target: T;
+};
+declare function hasSameSourceTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameSourceTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+declare function hasSameSource<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameSource<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+declare function hasSameTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+type WithId<T> = {
+    id: T;
+};
+declare function isOutgoing<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
+declare function isIncoming<T extends string>(target: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>>, target: WithId<T>): boolean;
+declare function isAnyInOut<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
+
+/**
+ * Resolve connection from source to target
+ * If direction is `both`, also look for reverse connection
+ *
+ * @default direction directed
+ */
+declare function findConnection$1<M extends AnyAux>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'directed'): readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection$1<M extends AnyAux>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection$1<M extends AnyAux>(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$1<M extends AnyAux>(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$1<M extends AnyAux>(elements: Iterable<DeploymentElementModel<M>>): readonly DeploymentConnectionModel<M>[];
+
+declare namespace find$1 {
+  export { findConnection$1 as findConnection, findConnectionsBetween$1 as findConnectionsBetween, findConnectionsWithin$1 as findConnectionsWithin };
+}
+
+/**
+ * Resolve connection from source to target
+ *
+ * @param direction - if 'both', also returns connection from target to source
+ * @default `directed`
+ */
+declare function findConnection<M extends AnyAux>(source: ElementModel<M>, target: ElementModel<M>, direction?: 'directed' | 'both'): [ConnectionModel<M>, ConnectionModel<M>] | [ConnectionModel<M>] | [];
+/**
+ * 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 AnyAux>(element: ElementModel<M>, others: Iterable<ElementModel<NoInfer<M>>>, direction?: 'directed' | 'both'): readonly ConnectionModel<M>[];
+/**
+ * Resolve all connections within a given set of elements
+ */
+declare function findConnectionsWithin<M extends AnyAux>(elements: Iterable<ElementModel<M>>): readonly ConnectionModel<M>[];
+
+declare const find_findConnection: typeof findConnection;
+declare const find_findConnectionsBetween: typeof findConnectionsBetween;
+declare const find_findConnectionsWithin: typeof findConnectionsWithin;
+declare namespace find {
+  export { find_findConnection as findConnection, find_findConnectionsBetween as findConnectionsBetween, find_findConnectionsWithin as findConnectionsWithin };
+}
+
+/**
+ * Used by vite plugin to generate `virtual:likec4/model`
+ */
+declare function createLikeC4Model(model: any): LikeC4Model;
+
+export { AnyAux, Connection, ConnectionModel, DeployedInstanceModel, DeploymentConnectionModel, DeploymentElementModel, DeploymentNodeModel, DeploymentRelationModel, ElementModel, Fqn, LikeC4Model, RelationshipModel, createLikeC4Model, find$1 as deploymentConnection, differenceConnections, findAscendingConnections, findDeepestNestedConnection, findDescendantConnections, hasSameSource, hasSameSourceTarget, hasSameTarget, isAnyInOut, isIncoming, isNestedConnection, isOutgoing, mergeConnections, find as modelConnection, sortConnectionsByBoundaryHierarchy, sortDeepestFirst };

package/dist/model/index.mjs

@@ -1 +1 @@
-import{j as e}from"../shared/likec4.LktBLTET.mjs";export{h as ComputedNode,v as ComputedView,a as Connection,Z as ConnectionModel,$ as DeployedInstanceModel,G as DeploymentConnectionModel,_ as DeploymentNodeModel,f as DeploymentRelationModel,W as DiagramNode,T as EdgeModel,m as ElementModel,M as LikeC4DeploymentModel,P as LikeC4ViewModel,z as NodeModel,L as RelationshipModel,R as deploymentConnection,b as differenceConnections,c as findAscendingConnections,I as findDeepestNestedConnection,y as findDescendantConnections,A as hasSameSource,d as hasSameSourceTarget,O as hasSameTarget,F as isAnyInOut,e as isIncoming,o as isNestedConnection,D as isOutgoing,s as mergeConnections,C as modelConnection,p as sortConnectionsByBoundaryHierarchy,g as sortDeepestFirst}from"../shared/likec4.LktBLTET.mjs";function n(o){return e.create(o)}export{e as LikeC4Model,n as createLikeC4Model};
+import{j as e}from"../shared/likec4.1r1CQuHw.mjs";export{h as ComputedNode,v as ComputedView,a as Connection,Z as ConnectionModel,$ as DeployedInstanceModel,G as DeploymentConnectionModel,_ as DeploymentNodeModel,f as DeploymentRelationModel,W as DiagramNode,T as EdgeModel,m as ElementModel,M as LikeC4DeploymentModel,P as LikeC4ViewModel,z as NodeModel,L as RelationshipModel,R as deploymentConnection,b as differenceConnections,c as findAscendingConnections,I as findDeepestNestedConnection,y as findDescendantConnections,A as hasSameSource,d as hasSameSourceTarget,O as hasSameTarget,F as isAnyInOut,e as isIncoming,o as isNestedConnection,D as isOutgoing,s as mergeConnections,C as modelConnection,p as sortConnectionsByBoundaryHierarchy,g as sortDeepestFirst}from"../shared/likec4.1r1CQuHw.mjs";function n(o){return e.create(o)}export{e as LikeC4Model,n as createLikeC4Model};