likec4 0.37.1 → 0.40.0-build.10

package/bin/likec4.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/cli/index.js'

package/dist/@likec4/core/colors.js

@@ -0,0 +1,104 @@
+const blue = {
+  // fill: colors.blue[500],
+  // stroke: colors.blue[600],
+  // hiContrast: colors.blue[50],
+  // loContrast: colors.blue[200],
+  fill: "#3b82f6",
+  stroke: "#2563eb",
+  hiContrast: "#eff6ff",
+  loContrast: "#bfdbfe"
+};
+const sky = {
+  // fill: colors.sky[600],
+  // stroke: colors.sky[700],
+  // hiContrast: colors.sky[50],
+  // loContrast: colors.sky[100],
+  fill: "#0284c7",
+  stroke: "#0369a1",
+  hiContrast: "#f0f9ff",
+  loContrast: "#e0f2fe"
+};
+const slate = {
+  // fill: colors.slate[500],
+  // stroke: colors.slate[600],
+  // hiContrast: colors.slate[50],
+  // loContrast: colors.slate[200],
+  fill: "#64748b",
+  stroke: "#475569",
+  hiContrast: "#f8fafc",
+  loContrast: "#e2e8f0"
+};
+export const RelationColors = {
+  lineColor: "#b1b1b1",
+  labelColor: "#b1b1b1"
+};
+export const Colors = {
+  primary: blue,
+  blue,
+  secondary: sky,
+  sky,
+  muted: slate,
+  slate,
+  gray: {
+    // fill: colors.neutral[500],
+    // stroke: colors.neutral[600],
+    // hiContrast: colors.neutral[50],
+    // loContrast: colors.neutral[200],
+    fill: "#737373",
+    stroke: "#525252",
+    hiContrast: "#fafafa",
+    loContrast: "#e5e5e5"
+  },
+  red: {
+    // fill: colors.red[500],
+    // stroke: colors.red[600],
+    // hiContrast: colors.red[50],
+    // loContrast: colors.red[200],
+    fill: "#b54548",
+    stroke: "#8c333a",
+    // hiContrast: '#fef2f2',
+    // loContrast: '#fecaca',
+    // hiContrast: '#191111', // colors.gray[900],
+    // loContrast: '#3b1219' // colors.gray[800],
+    hiContrast: "#f8fafc",
+    // hiContrast: '#f8fafc',
+    // loContrast: '#fdd8d8' // radix black red 12
+    loContrast: "#F9C6C6"
+  },
+  green: {
+    fill: "#428a4f",
+    stroke: "#2d5d39",
+    hiContrast: "#f8fafc",
+    loContrast: "#c2f0c2"
+  },
+  amber: {
+    // fill: colors.amber[600],
+    // stroke: colors.amber[700],
+    // hiContrast: colors.amber[50],
+    // loContrast: colors.amber[200],
+    fill: "#d97706",
+    stroke: "#b45309",
+    // hiContrast: '#fffbeb',
+    // loContrast: '#fde68a',
+    hiContrast: "#f8fafc",
+    // colors.gray[900],
+    loContrast: "#ffe0c2"
+    // colors.gray[800],
+  },
+  indigo: {
+    // fill: colors.indigo[500],
+    // stroke: colors.indigo[600],
+    // hiContrast: colors.indigo[50],
+    // loContrast: colors.indigo[200],
+    fill: "#6366f1",
+    stroke: "#4f46e5",
+    hiContrast: "#eef2ff",
+    loContrast: "#c7d2fe"
+  }
+};
+export const defaultTheme = {
+  font: "Helvetica",
+  shadow: "#0a0a0a",
+  relation: RelationColors,
+  colors: Colors
+};

package/dist/@likec4/core/compute-view/EdgeBuilder.js

@@ -0,0 +1,30 @@
+import { keys, pluck } from "rambdax";
+import { commonAncestor, compareRelations } from "../utils/index.js";
+export class EdgeBuilder {
+  _relationsObj = {};
+  add(source, target, relation) {
+    const bySource = this._relationsObj[source] ?? {};
+    const relations = bySource[target] ?? [];
+    relations.push(relation);
+    bySource[target] = relations;
+    this._relationsObj[source] = bySource;
+    return this;
+  }
+  build() {
+    return keys(this._relationsObj).flatMap((source) => {
+      const targets = this._relationsObj[source] ?? {};
+      return keys(targets).map((target) => {
+        const relations = (targets[target] ?? []).sort(compareRelations);
+        const label = relations.find((r) => r.title !== "")?.title ?? null;
+        return {
+          id: `${source}:${target}`,
+          parent: commonAncestor(source, target),
+          source,
+          target,
+          label,
+          relations: pluck("id", relations)
+        };
+      });
+    }).sort(compareRelations).reverse();
+  }
+}

package/dist/@likec4/core/compute-view/compute-ctx.js

@@ -0,0 +1,100 @@
+import { difference } from "rambdax";
+import { Expr, isStrictElementView, isViewRuleExpression } from "../types/index.js";
+import {
+  excludeElementKindOrTag,
+  excludeElementRef,
+  excludeInOutExpr,
+  excludeIncomingExpr,
+  excludeOutgoingExpr,
+  excludeRelationExpr,
+  excludeWildcardRef,
+  includeElementKindOrTag,
+  includeElementRef,
+  includeInOutExpr,
+  includeIncomingExpr,
+  includeOutgoingExpr,
+  includeRelationExpr,
+  includeWildcardRef
+} from "./compute-predicates.js";
+import { nonexhaustive } from "../errors/index.js";
+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;
+    this.allElements = /* @__PURE__ */ new Set([...this.elements, ...this.implicits]);
+  }
+  allElements;
+  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
+    );
+  }
+  processViewRules(viewRules) {
+    let ctx = this;
+    for (const { isInclude, exprs } of viewRules) {
+      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;
+        }
+        nonexhaustive(expr);
+      }
+    }
+    return ctx;
+  }
+  static create(view, index) {
+    const rootElement = isStrictElementView(view) ? 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)]
+      });
+    }
+    return ctx.processViewRules(rulesInclude);
+  }
+}

package/dist/@likec4/core/compute-view/compute-element-view.js

@@ -0,0 +1,98 @@
+import { allPass, find } from "remeda";
+import { nonNullable } from "../errors/index.js";
+import {
+  DefaultElementShape,
+  DefaultThemeColor,
+  isViewRuleAutoLayout,
+  isViewRuleStyle
+} from "../types/index.js";
+import { compareByFqnHierarchically, isAncestor, isSameHierarchy, parentFqn } from "../utils/index.js";
+import { EdgeBuilder } from "./EdgeBuilder.js";
+import { ComputeCtx } from "./compute-ctx.js";
+import { applyViewRuleStyles } from "./utils/applyViewRuleStyles.js";
+import { sortNodes } from "./utils/sortNodes.js";
+function reduceToMap(elementsIterator) {
+  return Array.from(elementsIterator).sort(compareByFqnHierarchically).reduce((map, { id, color, shape, ...el }) => {
+    let parent = parentFqn(id);
+    let level = 0;
+    while (parent) {
+      if (map.has(parent)) {
+        break;
+      }
+      parent = parentFqn(parent);
+    }
+    if (parent) {
+      const parentNd = nonNullable(map.get(parent));
+      parentNd.children.push(id);
+      level = parentNd.level + 1;
+    }
+    const node = {
+      ...el,
+      id,
+      parent,
+      level,
+      color: color ?? DefaultThemeColor,
+      shape: shape ?? DefaultElementShape,
+      children: [],
+      inEdges: [],
+      outEdges: []
+    };
+    map.set(id, node);
+    return map;
+  }, /* @__PURE__ */ new Map());
+}
+const keepOriginalSortFromView = (_nodes, ctx) => {
+  const nodes = [...ctx.allElements].flatMap((e) => _nodes.get(e.id) || []);
+  for (const node of nodes) {
+    node.children = nodes.flatMap((n) => n.parent === node.id ? n.id : []);
+  }
+  return nodes;
+};
+export function computeElementView(view, index) {
+  const ctx = ComputeCtx.create(view, index);
+  const leafsFirst = [...ctx.allElements].sort((a, b) => -1 * compareByFqnHierarchically(a, b));
+  const elementsWithRelations = /* @__PURE__ */ new Set();
+  const edgeBuilder = new EdgeBuilder();
+  const anscestorOf = (id) => (e) => e.id === id || isAncestor(e.id, id);
+  const sortedRelations = [...ctx.relations];
+  for (const rel of sortedRelations) {
+    const source = find(leafsFirst, anscestorOf(rel.source));
+    if (!source) {
+      continue;
+    }
+    const target = find(
+      leafsFirst,
+      allPass([anscestorOf(rel.target), (e) => !isSameHierarchy(e, source)])
+    );
+    if (!target) {
+      continue;
+    }
+    elementsWithRelations.add(source);
+    elementsWithRelations.add(target);
+    edgeBuilder.add(source.id, target.id, rel);
+  }
+  const nodesMap = reduceToMap(/* @__PURE__ */ new Set([...ctx.elements, ...elementsWithRelations]));
+  const edges = edgeBuilder.build().map((edge) => {
+    while (edge.parent) {
+      if (nodesMap.has(edge.parent)) {
+        break;
+      }
+      edge.parent = parentFqn(edge.parent);
+    }
+    nonNullable(nodesMap.get(edge.source)).outEdges.push(edge.id);
+    nonNullable(nodesMap.get(edge.target)).inEdges.push(edge.id);
+    return edge;
+  });
+  const nodes = applyViewRuleStyles(
+    view.rules.filter(isViewRuleStyle),
+    sortNodes(keepOriginalSortFromView(nodesMap, ctx), edges)
+    // map(e => nodesMap.get(e.id)!, Array.from(elements))
+  );
+  const autoLayoutRule = view.rules.find(isViewRuleAutoLayout);
+  return {
+    ...view,
+    autoLayout: autoLayoutRule?.autoLayout ?? "TB",
+    nodes,
+    edges
+  };
+}

package/dist/@likec4/core/compute-view/compute-predicates.js

@@ -0,0 +1,324 @@
+import { anyPass, both, either, isNil, uniq } from "rambdax";
+import { Expr } from "../types/index.js";
+import { Relations, commonAncestor, isAncestor, isSameHierarchy } from "../utils/index.js";
+import { ComputeCtx } from "./compute-ctx.js";
+const { isAnyInOut, isBetween, isIncoming, isInside, isOutgoing, isAnyBetween } = Relations;
+export const includeElementRef = (ctx, expr) => {
+  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
+  const filters = [];
+  if (expr.isDescedants) {
+    elements.forEach((child) => {
+      filters.push(both(isInside(expr.element), isAnyInOut(child.id)));
+    });
+  }
+  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(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 });
+};
+export 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);
+    }
+  }
+};
+export 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
+  );
+};
+export 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 });
+};
+export const includeWildcardRef = (ctx, _expr) => {
+  const { root } = ctx;
+  if (root) {
+    const elements = [ctx.index.find(root), ...ctx.index.children(root)];
+    const allImplicits = [
+      ...ctx.index.siblings(root),
+      ...ctx.index.ancestors(root).flatMap((a) => [...ctx.index.siblings(a.id)])
+    ];
+    const inOut = ctx.index.filterRelations(isAnyInOut(root));
+    const implicits = [];
+    for (const implicit of allImplicits) {
+      if (inOut.some(isAnyInOut(implicit.id))) {
+        implicits.push(implicit);
+      }
+    }
+    return ctx.include({
+      elements,
+      relations: [...ctx.index.filterRelations(isInside(root)), ...inOut],
+      implicits
+    });
+  } else {
+    const elements = ctx.index.rootElements();
+    if (elements.length <= 1) {
+      return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
+    }
+    const relations = ctx.index.filterRelations(
+      (rel) => isNil(commonAncestor(rel.source, rel.target))
+    );
+    return ctx.include({
+      elements,
+      relations
+    });
+  }
+};
+export const excludeWildcardRef = (ctx, _expr) => {
+  const { root } = ctx;
+  if (root) {
+    const relations = [...ctx.relations].filter(either(isInside(root), isAnyInOut(root)));
+    return ctx.exclude({
+      elements: [...ctx.elements].filter((e) => e.id === root || isAncestor(root, e.id)),
+      relations,
+      implicits: [...ctx.implicits].filter((e) => relations.some(isAnyInOut(e.id)))
+    });
+  } 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)];
+  }
+};
+export 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;
+  }
+  let allrelations = ctx.index.relations;
+  if (Expr.isElementRef(expr.incoming)) {
+    allrelations = allrelations.filter(isIncoming(expr.incoming.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const el of elements) {
+    const elRelations = allrelations.filter(isIncoming(el.id));
+    if (elRelations.length > 0) {
+      relations.push(...elRelations);
+      implicits.push(el);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+export 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;
+};
+export 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;
+  }
+  let allrelations = ctx.index.relations;
+  if (Expr.isElementRef(expr.outgoing)) {
+    allrelations = allrelations.filter(isOutgoing(expr.outgoing.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const el of elements) {
+    const elRelations = allrelations.filter(isOutgoing(el.id));
+    if (elRelations.length > 0) {
+      relations.push(...elRelations);
+      implicits.push(el);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+export 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;
+};
+export 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;
+  }
+  let allrelations = ctx.index.relations;
+  if (Expr.isElementRef(expr.inout)) {
+    allrelations = allrelations.filter(isAnyInOut(expr.inout.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const target of targets) {
+    const foundRelations = allrelations.filter(isAnyInOut(target.id));
+    if (foundRelations.length > 0) {
+      relations.push(...foundRelations);
+      implicits.push(target);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+export 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;
+};
+export 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
+  });
+};
+export 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
+  });
+};

package/dist/@likec4/core/compute-view/compute.js

@@ -0,0 +1,36 @@
+import { find } from "rambdax";
+import { normalizeError } from "../errors/index.js";
+import { computeElementView } from "./compute-element-view.js";
+export function computeView(view, index) {
+  try {
+    return {
+      isSuccess: true,
+      view: computeElementView(view, index)
+    };
+  } catch (e) {
+    return {
+      isSuccess: false,
+      error: normalizeError(e),
+      view: void 0
+    };
+  }
+}
+export function assignNavigateTo(views) {
+  const allElementViews = /* @__PURE__ */ new Map();
+  for (const v of views) {
+    if (v.viewOf && !v.extends) {
+      const viewsOf = allElementViews.get(v.viewOf) ?? [];
+      viewsOf.push(v.id);
+      allElementViews.set(v.viewOf, viewsOf);
+    }
+  }
+  for (const { id, nodes } of views) {
+    for (const node of nodes) {
+      const navigateTo = find((v) => v !== id, allElementViews.get(node.id) ?? []);
+      if (navigateTo) {
+        node.navigateTo = navigateTo;
+      }
+    }
+  }
+  return views;
+}

package/dist/@likec4/core/compute-view/index.js

@@ -0,0 +1,4 @@
+export * from "./compute.js";
+export * from "./resolve-extended-views.js";
+export * from "./resolve-relative-paths.js";
+export * from "./EdgeBuilder.js";