@likec4/core 0.31.0 → 0.33.0

package/dist/compute-view/compute-ctx.mjs

@@ -0,0 +1,42 @@
+import { difference } from "rambdax";
+export class ComputeCtx {
+  constructor(index, root, elements = /* @__PURE__ */ new Set(), relations = /* @__PURE__ */ new Set(), implicits = /* @__PURE__ */ new Set()) {
+    this.index = index;
+    this.root = root;
+    this.elements = elements;
+    this.relations = relations;
+    this.implicits = implicits;
+  }
+  include({
+    elements,
+    relations,
+    implicits
+  }) {
+    return new ComputeCtx(
+      this.index,
+      this.root,
+      elements ? /* @__PURE__ */ new Set([...this.elements, ...elements]) : this.elements,
+      relations ? /* @__PURE__ */ new Set([...this.relations, ...relations]) : this.relations,
+      implicits ? /* @__PURE__ */ new Set([...this.implicits, ...implicits]) : this.implicits
+    );
+  }
+  exclude({
+    elements,
+    relations,
+    implicits
+  }) {
+    let newImplicits = implicits ? new Set(difference([...this.implicits], implicits)) : this.implicits;
+    if (elements) {
+      newImplicits = new Set(
+        difference([...newImplicits], elements)
+      );
+    }
+    return new ComputeCtx(
+      this.index,
+      this.root,
+      elements ? new Set(difference([...this.elements], elements)) : this.elements,
+      relations ? new Set(difference([...this.relations], relations)) : this.relations,
+      newImplicits
+    );
+  }
+}

package/dist/compute-view/compute-element-view.d.ts

@@ -1,4 +1,3 @@
 import type { ModelIndex } from '../model-index';
-import { type ElementView, type ComputeResult } from '../types';
-export declare function computeElementView<V extends ElementView>(view: V, index: ModelIndex): ComputeResult<V>;
-//# sourceMappingURL=compute-element-view.d.ts.map
+import { type ElementView, type ComputedView } from '../types';
+export declare function computeElementView(view: ElementView, index: ModelIndex): ComputedView;

package/dist/compute-view/compute-element-view.js

@@ -1,471 +1,139 @@
-import { anyPass, filter, uniq, isNil } from 'rambdax';
-import { DefaultThemeColor, DefaultElementShape } from '../types';
-import * as Expr from '../types/expression';
-import { isViewRuleAutoLayout, isViewRuleExpression, isViewRuleStyle } from '../types/view';
-import { compareByFqnHierarchically, failExpectedNever, ignoreNeverInRuntime, isAncestor, isSameHierarchy, parentFqn, Relations } from '../utils';
-import { hasRelation, isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } from '../utils/relations';
-import { EdgeBuilder } from './EdgeBuilder';
-import { sortNodes } from './utils/sortNodes';
-import { ComputeCtx } from './compute-ctx';
-import { anyPossibleRelations } from './utils/anyPossibleRelations';
-import { invariant } from '../errors';
-function transformToNodes(elementsIterator) {
-    return Array.from(elementsIterator)
-        .sort(compareByFqnHierarchically)
-        .reduce((map, { id, color, shape, ...el }) => {
-        let parent = parentFqn(id);
-        while (parent) {
-            if (map.has(parent)) {
-                break;
-            }
-            parent = parentFqn(parent);
-        }
-        if (parent) {
-            const parentNd = map.get(parent);
-            invariant(parentNd, `parent node ${parent} not found`);
-            parentNd.children.push(id);
-        }
-        const node = {
-            ...el,
-            id,
-            parent,
-            color: color ?? DefaultThemeColor,
-            shape: shape ?? DefaultElementShape,
-            children: []
-        };
-        map.set(id, node);
-        return map;
-    }, new Map());
-}
-function applyViewRuleStyles(rules, nodes) {
-    for (const rule of rules) {
-        const predicates = [];
-        if (!rule.style.color && !rule.style.shape) {
-            // skip empty
-            continue;
-        }
-        for (const target of rule.targets) {
-            if (Expr.isWildcard(target)) {
-                predicates.push(() => true);
-                break;
-            }
-            if (Expr.isElementKindExpr(target)) {
-                predicates.push(target.isEqual ? n => n.kind === target.elementKind : n => n.kind !== target.elementKind);
-                continue;
-            }
-            if (Expr.isElementTagExpr(target)) {
-                predicates.push(target.isEqual
-                    ? ({ tags }) => !!tags && tags.includes(target.elementTag)
-                    : ({ tags }) => isNil(tags) || !tags.includes(target.elementTag));
-                continue;
-            }
-            if (Expr.isElementRef(target)) {
-                const { element, isDescedants } = target;
-                predicates.push(isDescedants ? n => n.id.startsWith(element + '.') : n => n.id === element);
-                continue;
-            }
-            failExpectedNever(target);
-        }
-        filter(anyPass(predicates), nodes).forEach(n => {
-            n.shape = rule.style.shape ?? n.shape;
-            n.color = rule.style.color ?? n.color;
-        });
-    }
-    return nodes;
-}
-const includeElementRef = (ctx, expr) => {
-    const elements = expr.isDescedants
-        ? ctx.index.children(expr.element)
-        : [ctx.index.find(expr.element)];
-    const filters = [];
-    if (expr.isDescedants) {
-        filters.push(Relations.isInside(expr.element));
-    }
-    const ctxElements = uniq([...ctx.elements, ...ctx.implicits]);
-    const excludeImplicits = [];
-    for (const el of elements) {
-        if (ctx.root && ctx.root !== el.id && !isAncestor(el.id, ctx.root)) {
-            excludeImplicits.push(...[...ctx.implicits].filter(impl => isAncestor(el.id, impl.id)));
-        }
-        for (const ctxEl of ctxElements) {
-            if (!isSameHierarchy(el, ctxEl)) {
-                filters.push(Relations.isAnyBetween(el.id, ctxEl.id));
-            }
-        }
-    }
-    const relations = filters.length ? ctx.index.filterRelations(anyPass(filters)) : [];
-    if (excludeImplicits.length == 0) {
-        return ctx.include({ elements, relations });
-    }
-    return ctx.include({ elements, relations }).exclude({ implicits: excludeImplicits });
-};
-const excludeElementRef = (ctx, expr) => {
-    const elements = expr.isDescedants
-        ? ctx.index.children(expr.element)
-        : [ctx.index.find(expr.element)];
-    const elementsIds = elements.map(e => e.id);
-    const relations = [...ctx.relations].filter(r => elementsIds.includes(r.source) || elementsIds.includes(r.target));
-    return ctx.exclude({ elements, relations });
-};
-const asElementPredicate = (expr) => {
-    if (expr.isEqual) {
-        if (Expr.isElementKindExpr(expr)) {
-            return e => e.kind === expr.elementKind;
-        }
-        else {
-            return ({ tags }) => !!tags && tags.includes(expr.elementTag);
-        }
-    }
-    else {
-        if (Expr.isElementKindExpr(expr)) {
-            return e => e.kind !== expr.elementKind;
-        }
-        else {
-            return ({ tags }) => isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-        }
-    }
-};
-const includeElementKindOrTag = (ctx, expr) => {
-    const elements = ctx.index.elements.filter(asElementPredicate(expr));
-    return elements.reduce((accCtx, el) => includeElementRef(accCtx, {
-        element: el.id,
-        isDescedants: false
-    }), ctx);
-};
-const excludeElementKindOrTag = (ctx, expr) => {
-    const predicate = asElementPredicate(expr);
-    const elements = [...ctx.elements].filter(predicate);
-    const implicits = [...ctx.implicits].filter(predicate);
-    return ctx.exclude({ elements, implicits });
-};
-const includeWildcardRef = (ctx, _expr) => {
-    const { root } = ctx;
-    if (root) {
-        const elements = [ctx.index.find(root), ...ctx.index.children(root)];
-        // All neighbors that may have relations with root or its children
-        const allImplicits = [
-            ...ctx.index.siblings(root),
-            ...ctx.index.ancestors(root).flatMap(a => [...ctx.index.siblings(a.id)])
-        ];
-        const allInOut = ctx.index.filterRelations(isAnyInOut(root));
-        // Neighbors that have relations with root or its children
-        const implicits = [];
-        const relations = [];
-        for (const implicit of allImplicits) {
-            const relationsWithImplicit = allInOut.filter(isAnyInOut(implicit.id));
-            if (relationsWithImplicit.length) {
-                implicits.push(implicit);
-                relations.push(...relationsWithImplicit);
-            }
-        }
-        return ctx.include({
-            elements,
-            relations: [...ctx.index.filterRelations(isInside(root)), ...relations],
-            implicits: implicits
-        });
-    }
-    else {
-        const elements = ctx.index.rootElements();
-        if (elements.length <= 1) {
-            return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
-        }
-        const predicates = [];
-        for (const [source, target] of anyPossibleRelations(elements)) {
-            predicates.push(Relations.isAnyBetween(source.id, target.id));
-        }
-        const relations = predicates.length ? ctx.index.filterRelations(anyPass(predicates)) : [];
-        return new ComputeCtx(ctx.index, ctx.root, new Set(elements), new Set(relations));
-    }
-};
-const excludeWildcardRef = (ctx, _expr) => {
-    const { root } = ctx;
-    if (root) {
-        const relations = [...ctx.relations].filter(anyPass([isInside(root), isIncoming(root), isOutgoing(root)]));
-        return ctx.exclude({
-            elements: [...ctx.elements].filter(e => isAncestor(root, e.id)),
-            relations,
-            implicits: [...ctx.implicits].filter(anyPass(relations.map(r => hasRelation(r))))
-        });
-    }
-    else {
-        return new ComputeCtx(ctx.index, ctx.root);
-    }
-};
-const resolveElements = (ctx, expr) => {
-    if (Expr.isWildcard(expr)) {
-        if (ctx.root) {
-            return [ctx.index.find(ctx.root)];
-        }
-        else {
-            return ctx.index.rootElements();
-        }
-    }
-    if (Expr.isElementKindExpr(expr)) {
-        return ctx.index.elements.filter(el => {
-            if (expr.isEqual) {
-                return el.kind === expr.elementKind;
-            }
-            return el.kind !== expr.elementKind;
-        });
-    }
-    if (Expr.isElementTagExpr(expr)) {
-        return ctx.index.elements.filter(el => {
-            const tags = el.tags;
-            if (expr.isEqual) {
-                return !!tags && tags.includes(expr.elementTag);
-            }
-            return isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-        });
-    }
-    if (expr.isDescedants) {
-        return ctx.index.children(expr.element);
-    }
-    else {
-        return [ctx.index.find(expr.element)];
-    }
-};
-const includeIncomingExpr = (ctx, expr) => {
-    if (Expr.isWildcard(expr.incoming) && !ctx.root) {
-        return ctx;
-    }
-    const elements = resolveElements(ctx, expr.incoming);
-    if (elements.length === 0) {
-        return ctx;
-    }
-    const implicits = [];
-    const relations = [];
-    for (const el of elements) {
-        const elRelations = ctx.index.filterRelations(isIncoming(el.id));
-        if (elRelations.length > 0) {
-            relations.push(...elRelations);
-            implicits.push(el);
-        }
-    }
-    return ctx.include({
-        relations,
-        implicits
-    });
-};
-const excludeIncomingExpr = (ctx, expr) => {
-    if (Expr.isWildcard(expr.incoming) && !ctx.root) {
-        return ctx;
-    }
-    const elements = resolveElements(ctx, expr.incoming);
-    if (elements.length === 0) {
-        return ctx;
-    }
-    const isIncomings = anyPass(elements.map(el => isIncoming(el.id)));
-    const excluded = [...ctx.relations].filter(isIncomings);
-    if (excluded.length > 0) {
-        return ctx.exclude({
-            relations: excluded
-        });
-    }
-    return ctx;
-};
-const includeOutgoingExpr = (ctx, expr) => {
-    if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
-        return ctx;
-    }
-    const elements = resolveElements(ctx, expr.outgoing);
-    if (elements.length === 0) {
-        return ctx;
-    }
-    const implicits = [];
-    const relations = [];
-    for (const el of elements) {
-        const elRelations = ctx.index.filterRelations(isOutgoing(el.id));
-        if (elRelations.length > 0) {
-            relations.push(...elRelations);
-            implicits.push(el);
-        }
-    }
-    return ctx.include({
-        relations,
-        implicits
-    });
-};
-const excludeOutgoingExpr = (ctx, expr) => {
-    if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
-        return ctx;
-    }
-    const elements = resolveElements(ctx, expr.outgoing);
-    if (elements.length === 0) {
-        return ctx;
-    }
-    const isOutgoings = anyPass(elements.map(el => isOutgoing(el.id)));
-    const excluded = [...ctx.relations].filter(isOutgoings);
-    if (excluded.length > 0) {
-        return ctx.exclude({
-            relations: excluded
-        });
-    }
-    return ctx;
-};
-const includeInOutExpr = (ctx, expr) => {
-    if (Expr.isWildcard(expr.inout) && !ctx.root) {
-        return ctx;
-    }
-    const targets = resolveElements(ctx, expr.inout);
-    if (targets.length === 0) {
-        return ctx;
-    }
-    const implicits = [];
-    const relations = [];
-    for (const target of targets) {
-        const foundRelations = ctx.index.filterRelations(isAnyInOut(target.id));
-        if (foundRelations.length > 0) {
-            relations.push(...foundRelations);
-            implicits.push(target);
-        }
-    }
-    return ctx.include({
-        relations,
-        implicits
-    });
-};
-const excludeInOutExpr = (ctx, expr) => {
-    if (Expr.isWildcard(expr.inout) && !ctx.root) {
-        return ctx;
-    }
-    const targets = resolveElements(ctx, expr.inout);
-    if (targets.length === 0) {
-        return ctx;
-    }
-    const excluded = [...ctx.relations].filter(anyPass(targets.map(t => isAnyInOut(t.id))));
-    if (excluded.length > 0) {
-        return ctx.exclude({
-            relations: excluded
-        });
-    }
-    return ctx;
-};
-const includeRelationExpr = (ctx, expr) => {
-    const sources = resolveElements(ctx, expr.source);
-    const targets = resolveElements(ctx, expr.target);
-    if (sources.length === 0 || targets.length === 0) {
-        return ctx;
-    }
-    const implicits = [];
-    const relations = [];
-    for (const source of sources) {
-        for (const target of targets) {
-            if (isSameHierarchy(source, target)) {
-                continue;
-            }
-            const foundRelations = ctx.index.filterRelations(isBetween(source.id, target.id));
-            if (foundRelations.length > 0) {
-                relations.push(...foundRelations);
-                implicits.push(source, target);
-            }
-        }
-    }
-    return ctx.include({
-        relations,
-        implicits
-    });
-};
-const excludeRelationExpr = (ctx, expr) => {
-    const sources = resolveElements(ctx, expr.source);
-    const targets = resolveElements(ctx, expr.target);
-    const filters = [];
-    for (const source of sources) {
-        for (const target of targets) {
-            if (isSameHierarchy(source, target)) {
-                continue;
-            }
-            filters.push(isBetween(source.id, target.id));
-        }
-    }
-    if (filters.length == 0) {
-        return ctx;
-    }
-    const excluded = [...ctx.relations].filter(anyPass(filters));
-    if (excluded.length == 0) {
-        return ctx;
-    }
-    return ctx.exclude({
-        relations: excluded
-    });
-};
-export function computeElementView(view, index) {
-    const rootElement = view.viewOf ?? null;
-    let ctx = new ComputeCtx(index, rootElement);
-    const rulesInclude = view.rules.filter(isViewRuleExpression);
-    if (rootElement && rulesInclude.length == 0) {
-        ctx = ctx.include({
-            elements: [index.find(rootElement)]
-        });
-    }
-    for (const { isInclude, exprs } of rulesInclude) {
-        for (const expr of exprs) {
-            if (Expr.isElementKindExpr(expr) || Expr.isElementTagExpr(expr)) {
-                ctx = isInclude ? includeElementKindOrTag(ctx, expr) : excludeElementKindOrTag(ctx, expr);
-                continue;
-            }
-            if (Expr.isElementRef(expr)) {
-                ctx = isInclude ? includeElementRef(ctx, expr) : excludeElementRef(ctx, expr);
-                continue;
-            }
-            if (Expr.isWildcard(expr)) {
-                ctx = isInclude ? includeWildcardRef(ctx, expr) : excludeWildcardRef(ctx, expr);
-                continue;
-            }
-            if (Expr.isIncoming(expr)) {
-                ctx = isInclude ? includeIncomingExpr(ctx, expr) : excludeIncomingExpr(ctx, expr);
-                continue;
-            }
-            if (Expr.isOutgoing(expr)) {
-                ctx = isInclude ? includeOutgoingExpr(ctx, expr) : excludeOutgoingExpr(ctx, expr);
-                continue;
-            }
-            if (Expr.isInOut(expr)) {
-                ctx = isInclude ? includeInOutExpr(ctx, expr) : excludeInOutExpr(ctx, expr);
-                continue;
-            }
-            if (Expr.isRelation(expr)) {
-                ctx = isInclude ? includeRelationExpr(ctx, expr) : excludeRelationExpr(ctx, expr);
-                continue;
-            }
-            ignoreNeverInRuntime(expr);
-        }
-    }
-    const elements = new Set([...ctx.elements]);
-    const edgeBuilder = new EdgeBuilder();
-    const resolvedRelations = [...ctx.relations];
-    for (const [source, target] of anyPossibleRelations([...elements, ...ctx.implicits])) {
-        if (!elements.has(source) && !elements.has(target)) {
-            continue;
-        }
-        const findPredicate = Relations.isBetween(source.id, target.id);
-        let idx = resolvedRelations.findIndex(findPredicate);
-        while (idx >= 0) {
-            const [rel] = resolvedRelations.splice(idx, 1);
-            if (rel) {
-                elements.add(source);
-                elements.add(target);
-                edgeBuilder.add(source.id, target.id, rel);
-            }
-            idx = resolvedRelations.findIndex(findPredicate);
-        }
-    }
-    const nodesreg = transformToNodes(elements);
-    const edges = edgeBuilder.build().map(edge => {
-        while (edge.parent) {
-            if (nodesreg.has(edge.parent)) {
-                break;
-            }
-            edge.parent = parentFqn(edge.parent);
-        }
-        return edge;
-    });
-    const nodes = applyViewRuleStyles(view.rules.filter(isViewRuleStyle), sortNodes(nodesreg, edges));
-    const autoLayoutRule = view.rules.find(isViewRuleAutoLayout);
-    return {
-        ...view,
-        autoLayout: autoLayoutRule?.autoLayout ?? 'TB',
-        nodes,
-        edges
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeElementView = computeElementView;
+var _remeda = require("remeda");
+var _errors = require("../errors");
+var _types = require("../types");
+var Expr = _interopRequireWildcard(require("../types/expression"));
+var _view = require("../types/view");
+var _utils = require("../utils");
+var _EdgeBuilder = require("./EdgeBuilder");
+var _computeCtx = require("./compute-ctx");
+var _computePredicates = require("./compute-predicates");
+var _applyViewRuleStyles = require("./utils/applyViewRuleStyles");
+var _sortNodes = require("./utils/sortNodes");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function reduceToMap(elementsIterator) {
+  return Array.from(elementsIterator).sort(_utils.compareByFqnHierarchically).reduce((map, {
+    id,
+    color,
+    shape,
+    ...el
+  }) => {
+    let parent = (0, _utils.parentFqn)(id);
+    while (parent) {
+      if (map.has(parent)) {
+        break;
+      }
+      parent = (0, _utils.parentFqn)(parent);
+    }
+    if (parent) {
+      const parentNd = (0, _errors.nonNullable)(map.get(parent));
+      parentNd.children.push(id);
+    }
+    const node = {
+      ...el,
+      id,
+      parent,
+      color: color ?? _types.DefaultThemeColor,
+      shape: shape ?? _types.DefaultElementShape,
+      children: [],
+      inEdges: [],
+      outEdges: []
     };
+    map.set(id, node);
+    return map;
+  }, /* @__PURE__ */new Map());
 }
-//# sourceMappingURL=compute-element-view.js.map
+function computeElementView(view, index) {
+  const rootElement = view.viewOf ?? null;
+  let ctx = new _computeCtx.ComputeCtx(index, rootElement);
+  const rulesInclude = view.rules.filter(_view.isViewRuleExpression);
+  if (rootElement && rulesInclude.length == 0) {
+    ctx = ctx.include({
+      elements: [index.find(rootElement)]
+    });
+  }
+  for (const {
+    isInclude,
+    exprs
+  } of rulesInclude) {
+    for (const expr of exprs) {
+      if (Expr.isElementKindExpr(expr) || Expr.isElementTagExpr(expr)) {
+        ctx = isInclude ? (0, _computePredicates.includeElementKindOrTag)(ctx, expr) : (0, _computePredicates.excludeElementKindOrTag)(ctx, expr);
+        continue;
+      }
+      if (Expr.isElementRef(expr)) {
+        ctx = isInclude ? (0, _computePredicates.includeElementRef)(ctx, expr) : (0, _computePredicates.excludeElementRef)(ctx, expr);
+        continue;
+      }
+      if (Expr.isWildcard(expr)) {
+        ctx = isInclude ? (0, _computePredicates.includeWildcardRef)(ctx, expr) : (0, _computePredicates.excludeWildcardRef)(ctx, expr);
+        continue;
+      }
+      if (Expr.isIncoming(expr)) {
+        ctx = isInclude ? (0, _computePredicates.includeIncomingExpr)(ctx, expr) : (0, _computePredicates.excludeIncomingExpr)(ctx, expr);
+        continue;
+      }
+      if (Expr.isOutgoing(expr)) {
+        ctx = isInclude ? (0, _computePredicates.includeOutgoingExpr)(ctx, expr) : (0, _computePredicates.excludeOutgoingExpr)(ctx, expr);
+        continue;
+      }
+      if (Expr.isInOut(expr)) {
+        ctx = isInclude ? (0, _computePredicates.includeInOutExpr)(ctx, expr) : (0, _computePredicates.excludeInOutExpr)(ctx, expr);
+        continue;
+      }
+      if (Expr.isRelation(expr)) {
+        ctx = isInclude ? (0, _computePredicates.includeRelationExpr)(ctx, expr) : (0, _computePredicates.excludeRelationExpr)(ctx, expr);
+        continue;
+      }
+      (0, _errors.nonexhaustive)(expr);
+    }
+  }
+  const allElements = [...ctx.elements, ...ctx.implicits].sort(_utils.compareByFqnHierarchically).reverse();
+  const elementsWithRelations = /* @__PURE__ */new Set();
+  const edgeBuilder = new _EdgeBuilder.EdgeBuilder();
+  const anscestorOf = id => e => e.id === id || (0, _utils.isAncestor)(e.id, id);
+  const sortedRelations = [...ctx.relations];
+  for (const rel of sortedRelations) {
+    const source = (0, _remeda.find)(allElements, anscestorOf(rel.source));
+    if (!source) {
+      continue;
+    }
+    const target = (0, _remeda.find)(allElements, (0, _remeda.allPass)([anscestorOf(rel.target), e => !(0, _utils.isSameHierarchy)(e, source)]));
+    if (!target) {
+      continue;
+    }
+    elementsWithRelations.add(source);
+    elementsWithRelations.add(target);
+    edgeBuilder.add(source.id, target.id, rel);
+  }
+  const elements = /* @__PURE__ */new Set([...ctx.elements, ...elementsWithRelations]);
+  const nodesMap = reduceToMap(elements);
+  const edges = edgeBuilder.build().map(edge => {
+    while (edge.parent) {
+      if (nodesMap.has(edge.parent)) {
+        break;
+      }
+      edge.parent = (0, _utils.parentFqn)(edge.parent);
+    }
+    (0, _errors.nonNullable)(nodesMap.get(edge.source)).outEdges.push(edge.id);
+    (0, _errors.nonNullable)(nodesMap.get(edge.target)).inEdges.push(edge.id);
+    return edge;
+  });
+  const nodes = (0, _applyViewRuleStyles.applyViewRuleStyles)(view.rules.filter(_view.isViewRuleStyle), (0, _sortNodes.sortNodes)(nodesMap, edges)
+  // map(e => nodesMap.get(e.id)!, Array.from(elements))
+  );
+
+  const autoLayoutRule = view.rules.find(_view.isViewRuleAutoLayout);
+  return {
+    ...view,
+    autoLayout: autoLayoutRule?.autoLayout ?? "TB",
+    nodes,
+    edges
+  };
+}