@likec4/language-server 1.14.0 → 1.15.1

package/dist/shared/{language-server.DFLaUdYu.mjs → language-server.BT4WTbFI.mjs}

@@ -1,5 +1,5 @@
-import { Expr, whereOperatorAsPredicate, parentFqn, nonexhaustive, isViewRuleStyle, compareByFqnHierarchically, DefaultThemeColor, DefaultElementShape, compareRelations, invariant, nonNullable, compareNatural, hasAtLeast, isAncestor, isViewRulePredicate, ancestorsFqn, isViewRuleAutoLayout, isScopedElementView, commonAncestor, StepEdgeId, isDynamicViewParallelSteps, isDynamicViewIncludeRule, DefaultRelationshipColor, DefaultLineStyle, DefaultArrowType, isSameHierarchy } from '@likec4/core';
-import { pipe, map, pick, mapToObj, isTruthy, isNullish, omitBy, isEmpty, filter, anyPass, isDefined, groupBy, prop, mapValues, piped, unique, entries, flatMap, sortBy, sort, difference, allPass, omit, hasAtLeast as hasAtLeast$1, only, reduce, isNonNull, isString, isArray } from 'remeda';
+import { Expr, whereOperatorAsPredicate, parentFqn, nonexhaustive, ComputedNode, isViewRuleGroup, isViewRulePredicate, isViewRuleStyle, nonNullable, ElementKind, compareByFqnHierarchically, DefaultThemeColor, DefaultElementShape, compareRelations, invariant, compareNatural, hasAtLeast, isAncestor, commonHead, isViewRuleAutoLayout, isScopedElementView, commonAncestor, StepEdgeId, isDynamicViewParallelSteps, isDynamicViewIncludeRule, DefaultRelationshipColor, DefaultLineStyle, DefaultArrowType, ancestorsFqn, isSameHierarchy } from '@likec4/core';
+import { pipe, map, pick, mapToObj, isTruthy, isNullish, omitBy, isEmpty, filter, isNot, anyPass, forEach, isDefined, groupBy, prop, mapValues, piped, unique, entries, flatMap, sortBy, sort, tap, difference, allPass, last, reverse, concat, omit, hasAtLeast as hasAtLeast$1, only, reduce, isNonNull, first, isString, isArray } from 'remeda';
 import dagre from '@dagrejs/dagre';
 import objectHash from 'object-hash';
 
@@ -54,8 +54,19 @@ function elementExprToPredicate(target) {
   nonexhaustive(target);
 }
 
+function flattenGroupRules(guard) {
+  return (rule) => {
+    if (isViewRuleGroup(rule)) {
+      return rule.groupRules.flatMap(flattenGroupRules(guard));
+    }
+    if (isViewRulePredicate(rule)) {
+      return "include" in rule ? rule.include.filter(guard) : [];
+    }
+    return [];
+  };
+}
 function applyCustomElementProperties(_rules, _nodes) {
-  const rules = _rules.flatMap((r) => "include" in r ? r.include.filter(Expr.isCustomElement) : []);
+  const rules = _rules.flatMap(flattenGroupRules(Expr.isCustomElement));
   if (rules.length === 0) {
     return _nodes;
   }
@@ -67,7 +78,7 @@ function applyCustomElementProperties(_rules, _nodes) {
     const notEmpty = !isEmpty(rest);
     const satisfies = elementExprToPredicate(expr);
     nodes.forEach((node, i) => {
-      if (!satisfies(node)) {
+      if (ComputedNode.isNodesGroup(node) || !satisfies(node)) {
         return;
       }
       if (notEmpty) {
@@ -103,7 +114,9 @@ function applyCustomElementProperties(_rules, _nodes) {
 function relationExpressionToPredicates(expr) {
   switch (true) {
     case Expr.isRelationWhere(expr):
-      return relationExpressionToPredicates(expr.where.expr);
+      const predicate = relationExpressionToPredicates(expr.where.expr);
+      const where = whereOperatorAsPredicate(expr.where.condition);
+      return (e) => predicate(e) && where(e);
     case Expr.isRelation(expr): {
       const isSource = elementExprToPredicate(expr.source);
       const isTarget = elementExprToPredicate(expr.target);
@@ -127,8 +140,9 @@ function relationExpressionToPredicates(expr) {
       nonexhaustive(expr);
   }
 }
+
 function applyCustomRelationProperties(_rules, nodes, _edges) {
-  const rules = _rules.flatMap((r) => "include" in r ? r.include.filter(Expr.isCustomRelationExpr) : []);
+  const rules = _rules.flatMap(flattenGroupRules(Expr.isCustomRelationExpr));
   const edges = Array.from(_edges);
   if (rules.length === 0 || edges.length === 0) {
     return edges;
@@ -144,12 +158,12 @@ function applyCustomRelationProperties(_rules, nodes, _edges) {
       if (!source || !target) {
         return;
       }
-      if (satisfies({ source, target })) {
+      if (satisfies({ source, target, ...pick(edge, ["kind", "tags"]) })) {
         edges[i] = {
           ...edge,
+          ...props,
           label: title ?? edge.label,
-          isCustomized: true,
-          ...props
+          isCustomized: true
         };
       }
     });
@@ -171,29 +185,34 @@ function applyViewRuleStyles(_rules, nodes) {
       }
       predicates.push(elementExprToPredicate(target));
     }
-    filter(nodes, anyPass(predicates)).forEach((n) => {
-      n.shape = rule.style.shape ?? n.shape;
-      n.color = rule.style.color ?? n.color;
-      if (isDefined(rule.style.icon)) {
-        n.icon = rule.style.icon;
-      }
-      if (isDefined(rule.notation)) {
-        n.notation = rule.notation;
-      }
-      let styleOverride;
-      if (isDefined(rule.style.border)) {
-        styleOverride = { border: rule.style.border };
-      }
-      if (isDefined(rule.style.opacity)) {
-        styleOverride = { ...styleOverride, opacity: rule.style.opacity };
-      }
-      if (styleOverride) {
-        n.style = {
-          ...n.style,
-          ...styleOverride
-        };
-      }
-    });
+    pipe(
+      nodes,
+      filter(isNot(ComputedNode.isNodesGroup)),
+      filter(anyPass(predicates)),
+      forEach((n) => {
+        n.shape = rule.style.shape ?? n.shape;
+        n.color = rule.style.color ?? n.color;
+        if (isDefined(rule.style.icon)) {
+          n.icon = rule.style.icon;
+        }
+        if (isDefined(rule.notation)) {
+          n.notation = rule.notation;
+        }
+        let styleOverride;
+        if (isDefined(rule.style.border)) {
+          styleOverride = { border: rule.style.border };
+        }
+        if (isDefined(rule.style.opacity)) {
+          styleOverride = { ...styleOverride, opacity: rule.style.opacity };
+        }
+        if (styleOverride) {
+          n.style = {
+            ...n.style,
+            ...styleOverride
+          };
+        }
+      })
+    );
   }
   return nodes;
 }
@@ -209,40 +228,80 @@ function updateDepthOfAncestors(node, nodes) {
     node = parentNd;
   }
 }
-function buildComputeNodes(elements) {
-  return Array.from(elements).sort(compareByFqnHierarchically).reduce((map, { id, color, shape, style, ...el }) => {
+function buildComputeNodes(elements, groups) {
+  const nodesMap = /* @__PURE__ */ new Map();
+  const elementToGroup = /* @__PURE__ */ new Map();
+  groups?.forEach(({ id, parent, viewRule, explicits }) => {
+    if (parent) {
+      nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id);
+    }
+    nodesMap.set(id, {
+      id,
+      parent,
+      kind: ElementKind.Group,
+      title: viewRule.title ?? "",
+      color: viewRule.color ?? "muted",
+      shape: "rectangle",
+      children: [],
+      inEdges: [],
+      outEdges: [],
+      level: 0,
+      depth: 0,
+      description: null,
+      technology: null,
+      tags: null,
+      links: null,
+      style: {
+        border: viewRule.border ?? "dashed",
+        opacity: viewRule.opacity ?? 0
+      }
+    });
+    for (const e of explicits) {
+      elementToGroup.set(e.id, id);
+    }
+  });
+  return Array.from(elements).sort(compareByFqnHierarchically).reduce((map, { id, color, shape, style, kind, title, ...el }) => {
     let parent = parentFqn(id);
     let level = 0;
+    let parentNd;
     while (parent) {
-      const parentNd = map.get(parent);
+      parentNd = map.get(parent);
       if (parentNd) {
-        if (parentNd.children.length == 0) {
-          parentNd.depth = 1;
-          updateDepthOfAncestors(parentNd, map);
-        }
-        parentNd.children.push(id);
-        level = parentNd.level + 1;
         break;
       }
       parent = parentFqn(parent);
     }
+    if (!parentNd && elementToGroup.has(id)) {
+      parent = elementToGroup.get(id);
+      parentNd = map.get(parent);
+    }
+    if (parentNd) {
+      if (parentNd.children.length == 0) {
+        parentNd.depth = 1;
+        updateDepthOfAncestors(parentNd, map);
+      }
+      parentNd.children.push(id);
+      level = parentNd.level + 1;
+    }
     const node = {
-      ...el,
       id,
       parent,
-      level,
+      kind,
+      title,
       color: color ?? DefaultThemeColor,
       shape: shape ?? DefaultElementShape,
       children: [],
       inEdges: [],
       outEdges: [],
+      level,
+      ...el,
       style: {
         ...style
       }
     };
     map.set(id, node);
     return map;
-  }, /* @__PURE__ */ new Map());
+  }, nodesMap);
 }
 
 function buildElementNotations(nodes) {
@@ -314,9 +373,16 @@ function sortNodes({
   nodes,
   edges
 }) {
-  if (edges.length === 0) {
+  if (nodes.length < 2) {
     return nodes;
   }
+  if (edges.length === 0) {
+    return pipe(
+      nodes,
+      sort(compareByFqnHierarchically),
+      tap(sortChildren)
+    );
+  }
   const g = new Graph({
     compound: false,
     directed: true,
@@ -351,15 +417,15 @@ function sortNodes({
   if (sources.length === 0) {
     sources = pipe(
       nodes,
-      sort(compareByFqnHierarchically),
       filter((n) => n.inEdges.length === 0 || n.parent === null),
+      sort(compareByFqnHierarchically),
       map((n) => n.id)
     );
   }
   const orderedIds = postorder(g, sources).reverse();
   const sorted = orderedIds.map(getNode);
   if (sorted.length < nodes.length) {
-    const unsorted = difference(nodes, sorted);
+    const unsorted = difference(nodes, sorted).sort(compareByFqnHierarchically);
     sorted.push(...unsorted);
   }
   invariant(sorted.length === nodes.length, "Not all nodes were processed by graphlib");
@@ -446,7 +512,9 @@ function includeWildcardRef(_expr, where = NoFilter) {
     ])
   ];
   for (const el of children) {
-    this.addEdges(this.graph.anyEdgesBetween(el, neighbours));
+    this.addEdges(this.graph.anyEdgesBetween(el, neighbours)).forEach((edge) => {
+      this.addImplicit(edge.source, edge.target);
+    });
   }
   if (!hasChildren && _elRoot) {
     const edgesWithSiblings = this.graph.anyEdgesBetween(_elRoot, this.graph.siblings(root));
@@ -637,8 +705,9 @@ function includeIncomingExpr(expr, where) {
   if (edges.length === 0) {
     return;
   }
-  this.addEdges(edges);
-  this.addImplicit(...edges.map((e) => e.target));
+  this.addEdges(edges).forEach((edge) => {
+    this.addImplicit(edge.target);
+  });
 }
 function excludeIncomingExpr(expr, where) {
   let relations = filterRelations(edgesIncomingExpr.call(this, expr.incoming), where);
@@ -678,8 +747,9 @@ function includeOutgoingExpr(expr, where) {
   if (edges.length === 0) {
     return;
   }
-  this.addEdges(edges);
-  this.addImplicit(...edges.map((e) => e.source));
+  this.addEdges(edges).forEach((edge) => {
+    this.addImplicit(edge.source);
+  });
 }
 function excludeOutgoingExpr(expr, where) {
   const relations = filterRelations(edgesOutgoingExpr.call(this, expr.outgoing), where);
@@ -764,7 +834,9 @@ function includeRelationExpr(expr, where) {
   if (expr.isBidirectional === true) {
     edges.push(...this.graph.edgesBetween(targets, sources));
   }
-  this.addEdges(filterEdges(edges, where));
+  this.addEdges(filterEdges(edges, where)).forEach((edge) => {
+    this.activeGroup.addImplicit(edge.source, edge.target);
+  });
 }
 function excludeRelationExpr(expr, where) {
   const isSource = elementExprToPredicate(expr.source);
@@ -787,6 +859,50 @@ function compareEdges(a, b) {
     { source: b.source.id, target: b.target.id }
   );
 }
+class NodesGroup {
+  constructor(id, viewRule, parent = null) {
+    this.id = id;
+    this.viewRule = viewRule;
+    this.parent = parent;
+  }
+  static kind = ElementKind.Group;
+  static root() {
+    return new NodesGroup("@root", { title: null, groupRules: [] });
+  }
+  static is(node) {
+    return node.kind === NodesGroup.kind;
+  }
+  explicits = /* @__PURE__ */ new Set();
+  implicits = /* @__PURE__ */ new Set();
+  /**
+   * Add element explicitly
+   * Included even without relationships
+   */
+  addElement(...el) {
+    for (const r of el) {
+      this.explicits.add(r);
+      this.implicits.add(r);
+    }
+  }
+  /**
+   * Add element implicitly
+   * Included if only has relationships
+   */
+  addImplicit(...el) {
+    for (const r of el) {
+      this.implicits.add(r);
+    }
+  }
+  excludeElement(...excludes) {
+    for (const el of excludes) {
+      this.explicits.delete(el);
+      this.implicits.delete(el);
+    }
+  }
+  isEmpty() {
+    return this.explicits.size === 0 && this.implicits.size === 0;
+  }
+}
 class ComputeCtx {
   constructor(view, graph) {
     this.view = view;
@@ -796,6 +912,16 @@ class ComputeCtx {
   explicits = /* @__PURE__ */ new Set();
   implicits = /* @__PURE__ */ new Set();
   ctxEdges = [];
+  /**
+   * Root group - not included in the groups
+   * But used to accumulate elements that are not in any group
+   */
+  __rootGroup = NodesGroup.root();
+  groups = [];
+  activeGroupStack = [];
+  get activeGroup() {
+    return this.activeGroupStack[0] ?? this.__rootGroup;
+  }
   static elementView(view, graph) {
     return new ComputeCtx(view, graph).compute();
   }
@@ -807,14 +933,30 @@ class ComputeCtx {
       rules,
       ...view
     } = this.view;
-    const viewPredicates = rules.filter(isViewRulePredicate);
+    const viewPredicates = rules.filter(anyPass([isViewRulePredicate, isViewRuleGroup]));
     if (this.root && viewPredicates.length == 0) {
       this.addElement(this.graph.element(this.root));
     }
     this.processPredicates(viewPredicates);
     this.removeRedundantImplicitEdges();
+    if (this.groups.length > 0) {
+      this.cleanGroupElements();
+    }
     const elements = [...this.includedElements];
-    const nodesMap = buildComputeNodes(elements);
+    const nodesMap = buildComputeNodes(elements, this.groups);
+    const ancestorsOf = (node) => {
+      const ancestors = [];
+      let parent = node.parent;
+      while (parent) {
+        const parentNode = nodesMap.get(parent);
+        if (!parentNode) {
+          break;
+        }
+        ancestors.push(parentNode);
+        parent = parentNode.parent;
+      }
+      return ancestors;
+    };
     const edgesMap = /* @__PURE__ */ new Map();
     const edges = this.computeEdges();
     for (const edge of edges) {
@@ -823,25 +965,37 @@ class ComputeCtx {
       const target = nodesMap.get(edge.target);
       invariant(source, `Source node ${edge.source} not found`);
       invariant(target, `Target node ${edge.target} not found`);
-      while (edge.parent && !nodesMap.has(edge.parent)) {
-        edge.parent = parentFqn(edge.parent);
-      }
+      const sourceAncestors = ancestorsOf(source);
+      const targetAncestors = ancestorsOf(target);
+      const edgeParent = last(
+        commonHead(
+          reverse(sourceAncestors),
+          reverse(targetAncestors)
+        )
+      );
+      edge.parent = edgeParent?.id ?? null;
       source.outEdges.push(edge.id);
       target.inEdges.push(edge.id);
-      for (const sourceAncestor of ancestorsFqn(edge.source)) {
-        if (sourceAncestor === edge.parent) {
+      for (const sourceAncestor of sourceAncestors) {
+        if (sourceAncestor === edgeParent) {
           break;
         }
-        nodesMap.get(sourceAncestor)?.outEdges.push(edge.id);
+        sourceAncestor.outEdges.push(edge.id);
       }
-      for (const targetAncestor of ancestorsFqn(edge.target)) {
-        if (targetAncestor === edge.parent) {
+      for (const targetAncestor of targetAncestors) {
+        if (targetAncestor === edgeParent) {
           break;
         }
-        nodesMap.get(targetAncestor)?.inEdges.push(edge.id);
+        targetAncestor.inEdges.push(edge.id);
       }
     }
-    const initialSort = elements.flatMap((e) => nodesMap.get(e.id) ?? []);
+    let initialSort = elements.map((e) => nonNullable(nodesMap.get(e.id), `Node ${e.id} not found in nodesMap`));
+    if (this.groups.length > 0) {
+      initialSort = concat(
+        this.groups.map((g) => nonNullable(nodesMap.get(g.id), `Node ${g.id} not found in nodesMap`)),
+        initialSort
+      );
+    }
     const nodes = applyCustomElementProperties(
       rules,
       applyViewRuleStyles(
@@ -987,6 +1141,7 @@ class ComputeCtx {
     return this.ctxEdges;
   }
   addEdges(edges) {
+    const added = [];
     for (const e of edges) {
       if (!hasAtLeast$1(e.relations, 1)) {
         continue;
@@ -996,10 +1151,13 @@ class ComputeCtx {
       );
       if (existing) {
         existing.relations = unique([...existing.relations, ...e.relations]);
+        added.push(existing);
         continue;
       }
+      added.push(e);
       this.ctxEdges.push(e);
     }
+    return added;
   }
   /**
    * Add element explicitly
@@ -1007,6 +1165,14 @@ class ComputeCtx {
    */
   addElement(...el) {
     for (const r of el) {
+      if (!this.explicits.has(r)) {
+        this.activeGroup.addElement(r);
+      } else if (this.activeGroup !== this.__rootGroup) {
+        this.groups.forEach((g) => {
+          g.implicits.delete(r);
+        });
+        this.activeGroup.addImplicit(r);
+      }
       this.explicits.add(r);
       this.implicits.add(r);
     }
@@ -1018,7 +1184,13 @@ class ComputeCtx {
   addImplicit(...el) {
     for (const r of el) {
       this.implicits.add(r);
+      if (this.activeGroup !== this.__rootGroup) {
+        this.groups.forEach((g) => {
+          g.implicits.delete(r);
+        });
+      }
     }
+    this.activeGroup.addImplicit(...el);
   }
   excludeElement(...excludes) {
     for (const el of excludes) {
@@ -1026,12 +1198,11 @@ class ComputeCtx {
       this.explicits.delete(el);
       this.implicits.delete(el);
     }
+    this.__rootGroup.excludeElement(...excludes);
+    this.groups.forEach((g) => {
+      g.excludeElement(...excludes);
+    });
   }
-  // protected excludeImplicit(...excludes: Element[]) {
-  //   for (const el of excludes) {
-  //     this.implicits.delete(el)
-  //   }
-  // }
   excludeRelation(...relations) {
     if (relations.length === 0) {
       return;
@@ -1063,11 +1234,15 @@ class ComputeCtx {
     const remaining = this.includedElements;
     if (remaining.size === 0) {
       this.implicits.clear();
+      this.__rootGroup.implicits.clear();
+      this.groups.forEach((g) => g.implicits.clear());
       return;
     }
     for (const el of excludedImplicits) {
       if (!remaining.has(el)) {
         this.implicits.delete(el);
+        this.__rootGroup.implicits.delete(el);
+        this.groups.forEach((g) => g.implicits.delete(el));
       }
     }
   }
@@ -1075,6 +1250,9 @@ class ComputeCtx {
     this.explicits.clear();
     this.implicits.clear();
     this.ctxEdges = [];
+    this.__rootGroup = NodesGroup.root();
+    this.groups = [];
+    this.activeGroupStack = [];
   }
   // Filter out edges if there are edges between descendants
   // i.e. remove implicit edges, derived from childs
@@ -1117,8 +1295,41 @@ class ComputeCtx {
       return acc;
     }, []);
   }
+  cleanGroupElements() {
+    const unprocessed = new Set(difference(
+      [...this.includedElements],
+      [...this.__rootGroup.explicits]
+    ));
+    for (const group of this.groups) {
+      const explicits = [...group.explicits];
+      group.explicits.clear();
+      for (const el of explicits) {
+        if (unprocessed.delete(el)) {
+          group.explicits.add(el);
+        }
+      }
+    }
+    for (const group of this.groups) {
+      for (const el of group.implicits) {
+        if (unprocessed.delete(el)) {
+          group.explicits.add(el);
+        }
+      }
+      group.implicits.clear();
+    }
+  }
   processPredicates(viewRules) {
     for (const rule of viewRules) {
+      if (isViewRuleGroup(rule)) {
+        const parent = first(this.activeGroupStack);
+        const groupId = `@gr${this.groups.length + 1}`;
+        const group = new NodesGroup(groupId, rule, parent?.id ?? null);
+        this.groups.push(group);
+        this.activeGroupStack.unshift(group);
+        this.processPredicates(rule.groupRules);
+        this.activeGroupStack.shift();
+        continue;
+      }
       const isInclude = "include" in rule;
       const exprs = rule.include ?? rule.exclude;
       for (const expr of exprs) {