@likec4/core 1.32.2 → 1.34.0

package/dist/shared/core.BTnf14gD.mjs

@@ -0,0 +1,331 @@
+import { c as customInspectSymbol } from './core.C80Z37Eu.mjs';
+import { o } from './core.BgvIuGGU.mjs';
+import { a as intersection, b as stringHash, u as union, d as difference, e as equals } from './core.CpwrZi3D.mjs';
+import { u } from './core.DbRvwARP.mjs';
+import { m } from './core.ByrmCl9I.mjs';
+import { j as isDescendantOf, i as isAncestor, q as isString, C, l as sortNaturalByFqn, k as isSameHierarchy } from './core.C_C-3c1S.mjs';
+import { i as isome } from './core.BoyJPEen.mjs';
+import { i as ifilter } from './core.BH9nN-_I.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
+
+function p(...e){return u(t,e)}var t=(e,o)=>e[o];
+
+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;
+}
+const boundaryHierarchy = (conn) => 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 C(
+    connections,
+    m((conn) => ({
+      id: boundaryHierarchy(conn),
+      conn
+    })),
+    sortNaturalByFqn(order),
+    m(p("conn"))
+  );
+}
+function findAscendingConnections(connections, connection) {
+  return connections.filter((c) => isNestedConnection(connection, c));
+}
+function findDescendantConnections(connections, connection) {
+  return connections.filter(isNestedConnection(connection));
+}
+function mergeConnections(connections) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const conn of connections) {
+    const existing = map2.get(conn.id);
+    if (existing) {
+      map2.set(conn.id, conn.mergeWith(existing));
+    } else {
+      map2.set(conn.id, conn);
+    }
+  }
+  return [...map2.values()];
+}
+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 (b2) => a.source === b2.source && a.target === b2.target;
+}
+function hasSameSource(a, b) {
+  if (b) {
+    return a.source === b.source;
+  }
+  return (b2) => a.source === b2.source;
+}
+function hasSameTarget(a, b) {
+  if (b) {
+    return a.target === b.target;
+  }
+  return (b2) => a.target === b2.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);
+}
+
+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 [];
+}
+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
+  ];
+}
+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;
+  }, []);
+}
+
+const modelConnection = {
+  __proto__: null,
+  findConnection: findConnection,
+  findConnectionsBetween: findConnectionsBetween,
+  findConnectionsWithin: findConnectionsWithin
+};
+
+class ConnectionModel {
+  constructor(source, target, relations = /* @__PURE__ */ new Set()) {
+    this.source = source;
+    this.target = target;
+    this.relations = relations;
+    this.id = stringHash(`model:${source.id}:${target.id}`);
+  }
+  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, o(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)
+   * @param search - When true, attempts to find an existing connection between the reversed nodes
+   */
+  reversed(search = false) {
+    if (!search) {
+      return new ConnectionModel(this.target, this.source);
+    }
+    const [found] = findConnection(this.target, this.source, "directed");
+    return found ?? new ConnectionModel(this.target, this.source, /* @__PURE__ */ new Set());
+  }
+}
+
+export { ConnectionModel as C, findDeepestNestedConnection as a, findDescendantConnections as b, hasSameSourceTarget as c, differenceConnections as d, hasSameTarget as e, findAscendingConnections as f, isIncoming as g, hasSameSource as h, isAnyInOut as i, isNestedConnection as j, isOutgoing as k, sortDeepestFirst as l, mergeConnections as m, modelConnection as n, findConnectionsBetween as o, p, findConnection as q, findConnectionsWithin as r, sortConnectionsByBoundaryHierarchy as s };

package/dist/shared/core.BgvIuGGU.mjs

@@ -0,0 +1,3 @@
+function o(a){return t=>!a(t)}
+
+export { o };

package/dist/shared/core.BoyJPEen.mjs

@@ -0,0 +1,21 @@
+import { t } from './core.BH9nN-_I.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
+
+function isome(arg1, arg2) {
+  const pred = arg2 ?? arg1;
+  invariant(t(pred));
+  function _some(iter) {
+    for (const value of iter) {
+      if (pred(value)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (!arg2) {
+    return _some;
+  }
+  return _some(arg1);
+}
+
+export { isome as i };

package/dist/shared/{core.CUYDgv2-.mjs → core.Br7Fab9l.mjs}

@@ -1,4 +1,7 @@
-import { i as invariant, t as t$1, a as nonexhaustive } from './core.Cy9smucx.mjs';
+import { t as t$1 } from './core.zLlww-07.mjs';
+import { n as n$1 } from './core.D56nCp7e.mjs';
+import { i as invariant, n as nonexhaustive } from './core.D4npX2q8.mjs';
+import { o } from './core.BgvIuGGU.mjs';
 import { u } from './core.DbRvwARP.mjs';
 
 function isOnStage(value, stage) {
@@ -7,16 +10,19 @@ function isOnStage(value, stage) {
 const _stage = "_stage";
 const _type = "_type";
 
-function n$1(e){return !!e}
-
 function n(e){return e==null}
 
-function o(a){return t=>!a(t)}
-
 function t(...a){return u(e,a)}var e=(a,o)=>o.every(l=>l(a));
 
 function y(...a){return u(r,a)}var r=(a,o)=>o.some(e=>e(a));
 
+function flattenMarkdownOrString(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  const content = t$1(value) ? value : value.txt ?? value.md;
+  return n$1(content?.trim()) ? content : null;
+}
 function Fqn(name, parent) {
   return parent ? parent + "." + name : name;
 }
@@ -121,15 +127,6 @@ function isDeployedInstance(el) {
   return "element" in el && n$1(el.element);
 }
 
-const DefaultThemeColor = "primary";
-const DefaultElementShape = "rectangle";
-const DefaultShapeSize = "md";
-const DefaultPaddingSize = "md";
-const DefaultTextSize = "md";
-const DefaultLineStyle = "dashed";
-const DefaultArrowType = "normal";
-const DefaultRelationshipColor = "gray";
-
 function isTagEqual(operator) {
   return "tag" in operator;
 }
@@ -211,4 +208,4 @@ function participantIs(participant, predicate) {
   };
 }
 
-export { DeploymentFqn as A, GlobalFqn as B, isGlobalFqn as C, DefaultElementShape as D, splitGlobalFqn as E, FqnRef as F, GroupElementKind as G, EdgeId as H, extractStep as I, NodeId as N, RelationId as R, StepEdgeKind as S, ViewId as V, _type as _, DefaultThemeColor as a, _stage as b, n$1 as c, isStepEdgeId as d, isGroupElementKind as e, DefaultArrowType as f, DefaultLineStyle as g, DefaultRelationshipColor as h, isDeployedInstance as i, isOnStage as j, isDeploymentNode as k, DefaultShapeSize as l, DefaultPaddingSize as m, n, o, DefaultTextSize as p, isTagEqual as q, isKindEqual as r, stepEdgeId as s, isParticipantOperator as t, isNotOperator as u, isAndOperator as v, whereOperatorAsPredicate as w, isOrOperator as x, y, Fqn as z };
+export { DeploymentFqn as D, EdgeId as E, FqnRef as F, GroupElementKind as G, NodeId as N, RelationId as R, StepEdgeKind as S, ViewId as V, _stage as _, _type as a, isDeploymentNode as b, isDeployedInstance as c, isTagEqual as d, isKindEqual as e, isParticipantOperator as f, isNotOperator as g, isAndOperator as h, isOnStage as i, isOrOperator as j, flattenMarkdownOrString as k, Fqn as l, isGroupElementKind as m, GlobalFqn as n, isGlobalFqn as o, stepEdgeId as p, isStepEdgeId as q, extractStep as r, splitGlobalFqn as s, n as t, whereOperatorAsPredicate as w, y };

package/dist/shared/{core.BrCnZFTn.mjs → core.Btl47GOn.mjs}

@@ -1,5 +1,5 @@
-import { t } from './core.rmvsy0n3.mjs';
-import { i as invariant } from './core.Cy9smucx.mjs';
+import { t } from './core.BH9nN-_I.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
 
 function imap(arg1, arg2) {
   const mapper = arg2 ?? arg1;
@@ -29,4 +29,4 @@ function toSet(iterable) {
   return (it) => new Set(it);
 }
 
-export { toArray as a, imap as i, toSet as t };
+export { toSet as a, imap as i, toArray as t };

package/dist/shared/core.ByrmCl9I.mjs

@@ -0,0 +1,5 @@
+import { u } from './core.DbRvwARP.mjs';
+
+function m(...a){return u(o,a,p)}var o=(a,e)=>a.map(e),p=a=>(e,t,r)=>({done:false,hasNext:true,next:a(e,t,r)});
+
+export { m };

package/dist/shared/core.C80Z37Eu.mjs

@@ -0,0 +1,29 @@
+import { i as isAncestor } from './core.C_C-3c1S.mjs';
+
+var Connection;
+((Connection2) => {
+  Connection2.isInside = (fqn) => {
+    return (connection) => isAncestor(fqn, connection.source.id) && isAncestor(fqn, connection.target.id);
+  };
+  Connection2.isDirectedBetween = (source, target) => {
+    return (connection) => (connection.source.id === source || isAncestor(source, connection.source.id)) && (connection.target.id === target || isAncestor(target, connection.target.id));
+  };
+  Connection2.isAnyBetween = (source, target) => {
+    const forward = (0, Connection2.isDirectedBetween)(source, target), backward = (0, Connection2.isDirectedBetween)(target, source);
+    return (connection) => forward(connection) || backward(connection);
+  };
+  Connection2.isIncoming = (target) => {
+    return (connection) => (connection.target.id === target || isAncestor(target, connection.target.id)) && !isAncestor(target, connection.source.id);
+  };
+  Connection2.isOutgoing = (source) => {
+    return (connection) => (connection.source.id === source || isAncestor(source, connection.source.id)) && !isAncestor(source, connection.target.id);
+  };
+  Connection2.isAnyInOut = (source) => {
+    const isIn = (0, Connection2.isIncoming)(source), isOut = (0, Connection2.isOutgoing)(source);
+    return (connection) => isIn(connection) || isOut(connection);
+  };
+})(Connection || (Connection = {}));
+
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+
+export { Connection as C, customInspectSymbol as c };

package/dist/shared/{core.Pf5I9o0e.d.mts → core.CF82MWyh.d.mts}

@@ -1,4 +1,4 @@
-import { F as Fqn } from './core.BuO4ncfY.mjs';
+import { F as Fqn } from './core.668kXpZq.mjs';
 
 declare function parentFqn<E extends string>(fqn: E): E | null;
 declare function nameFromFqn<E extends string>(fqn: E): string;

package/dist/shared/core.CJSFKrYf.d.mts

@@ -0,0 +1,83 @@
+import { C as Connection, c as customInspectSymbol } from './core.D3xEWj5B.mjs';
+import { E as ElementModel, R as RelationshipModel } from './core.DrS4Bf4y.mjs';
+import { A as Any, U as Unknown, B as EdgeId } from './core.DAj3LuFH.mjs';
+
+/**
+ * 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)
+     * @param search - When true, attempts to find an existing connection between the reversed nodes
+     */
+    reversed(search?: boolean): ConnectionModel<A>;
+}
+
+/**
+ * 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>[];
+
+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 };
+}
+
+export { ConnectionModel as C, findConnection as a, findConnectionsBetween as b, findConnectionsWithin as c, find as f };