@likec4/language-server 1.14.0 → 1.15.1

package/dist/shared/{language-server.CbDa016p.cjs → language-server.B8s2wfT_.cjs}

@@ -61,8 +61,19 @@ function elementExprToPredicate(target) {
   core.nonexhaustive(target);
 }
 
+function flattenGroupRules(guard) {
+  return (rule) => {
+    if (core.isViewRuleGroup(rule)) {
+      return rule.groupRules.flatMap(flattenGroupRules(guard));
+    }
+    if (core.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(core.Expr.isCustomElement) : []);
+  const rules = _rules.flatMap(flattenGroupRules(core.Expr.isCustomElement));
   if (rules.length === 0) {
     return _nodes;
   }
@@ -74,7 +85,7 @@ function applyCustomElementProperties(_rules, _nodes) {
     const notEmpty = !remeda.isEmpty(rest);
     const satisfies = elementExprToPredicate(expr);
     nodes.forEach((node, i) => {
-      if (!satisfies(node)) {
+      if (core.ComputedNode.isNodesGroup(node) || !satisfies(node)) {
         return;
       }
       if (notEmpty) {
@@ -110,7 +121,9 @@ function applyCustomElementProperties(_rules, _nodes) {
 function relationExpressionToPredicates(expr) {
   switch (true) {
     case core.Expr.isRelationWhere(expr):
-      return relationExpressionToPredicates(expr.where.expr);
+      const predicate = relationExpressionToPredicates(expr.where.expr);
+      const where = core.whereOperatorAsPredicate(expr.where.condition);
+      return (e) => predicate(e) && where(e);
     case core.Expr.isRelation(expr): {
       const isSource = elementExprToPredicate(expr.source);
       const isTarget = elementExprToPredicate(expr.target);
@@ -134,8 +147,9 @@ function relationExpressionToPredicates(expr) {
       core.nonexhaustive(expr);
   }
 }
+
 function applyCustomRelationProperties(_rules, nodes, _edges) {
-  const rules = _rules.flatMap((r) => "include" in r ? r.include.filter(core.Expr.isCustomRelationExpr) : []);
+  const rules = _rules.flatMap(flattenGroupRules(core.Expr.isCustomRelationExpr));
   const edges = Array.from(_edges);
   if (rules.length === 0 || edges.length === 0) {
     return edges;
@@ -151,12 +165,12 @@ function applyCustomRelationProperties(_rules, nodes, _edges) {
       if (!source || !target) {
         return;
       }
-      if (satisfies({ source, target })) {
+      if (satisfies({ source, target, ...remeda.pick(edge, ["kind", "tags"]) })) {
         edges[i] = {
           ...edge,
+          ...props,
           label: title ?? edge.label,
-          isCustomized: true,
-          ...props
+          isCustomized: true
         };
       }
     });
@@ -178,29 +192,34 @@ function applyViewRuleStyles(_rules, nodes) {
       }
       predicates.push(elementExprToPredicate(target));
     }
-    remeda.filter(nodes, remeda.anyPass(predicates)).forEach((n) => {
-      n.shape = rule.style.shape ?? n.shape;
-      n.color = rule.style.color ?? n.color;
-      if (remeda.isDefined(rule.style.icon)) {
-        n.icon = rule.style.icon;
-      }
-      if (remeda.isDefined(rule.notation)) {
-        n.notation = rule.notation;
-      }
-      let styleOverride;
-      if (remeda.isDefined(rule.style.border)) {
-        styleOverride = { border: rule.style.border };
-      }
-      if (remeda.isDefined(rule.style.opacity)) {
-        styleOverride = { ...styleOverride, opacity: rule.style.opacity };
-      }
-      if (styleOverride) {
-        n.style = {
-          ...n.style,
-          ...styleOverride
-        };
-      }
-    });
+    remeda.pipe(
+      nodes,
+      remeda.filter(remeda.isNot(core.ComputedNode.isNodesGroup)),
+      remeda.filter(remeda.anyPass(predicates)),
+      remeda.forEach((n) => {
+        n.shape = rule.style.shape ?? n.shape;
+        n.color = rule.style.color ?? n.color;
+        if (remeda.isDefined(rule.style.icon)) {
+          n.icon = rule.style.icon;
+        }
+        if (remeda.isDefined(rule.notation)) {
+          n.notation = rule.notation;
+        }
+        let styleOverride;
+        if (remeda.isDefined(rule.style.border)) {
+          styleOverride = { border: rule.style.border };
+        }
+        if (remeda.isDefined(rule.style.opacity)) {
+          styleOverride = { ...styleOverride, opacity: rule.style.opacity };
+        }
+        if (styleOverride) {
+          n.style = {
+            ...n.style,
+            ...styleOverride
+          };
+        }
+      })
+    );
   }
   return nodes;
 }
@@ -216,40 +235,80 @@ function updateDepthOfAncestors(node, nodes) {
     node = parentNd;
   }
 }
-function buildComputeNodes(elements) {
-  return Array.from(elements).sort(core.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) {
+      core.nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id);
+    }
+    nodesMap.set(id, {
+      id,
+      parent,
+      kind: core.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(core.compareByFqnHierarchically).reduce((map, { id, color, shape, style, kind, title, ...el }) => {
     let parent = core.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 = core.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 ?? core.DefaultThemeColor,
       shape: shape ?? core.DefaultElementShape,
       children: [],
       inEdges: [],
       outEdges: [],
+      level,
+      ...el,
       style: {
         ...style
       }
     };
     map.set(id, node);
     return map;
-  }, /* @__PURE__ */ new Map());
+  }, nodesMap);
 }
 
 function buildElementNotations(nodes) {
@@ -321,9 +380,16 @@ function sortNodes({
   nodes,
   edges
 }) {
-  if (edges.length === 0) {
+  if (nodes.length < 2) {
     return nodes;
   }
+  if (edges.length === 0) {
+    return remeda.pipe(
+      nodes,
+      remeda.sort(core.compareByFqnHierarchically),
+      remeda.tap(sortChildren)
+    );
+  }
   const g = new Graph({
     compound: false,
     directed: true,
@@ -358,15 +424,15 @@ function sortNodes({
   if (sources.length === 0) {
     sources = remeda.pipe(
       nodes,
-      remeda.sort(core.compareByFqnHierarchically),
       remeda.filter((n) => n.inEdges.length === 0 || n.parent === null),
+      remeda.sort(core.compareByFqnHierarchically),
       remeda.map((n) => n.id)
     );
   }
   const orderedIds = postorder(g, sources).reverse();
   const sorted = orderedIds.map(getNode);
   if (sorted.length < nodes.length) {
-    const unsorted = remeda.difference(nodes, sorted);
+    const unsorted = remeda.difference(nodes, sorted).sort(core.compareByFqnHierarchically);
     sorted.push(...unsorted);
   }
   core.invariant(sorted.length === nodes.length, "Not all nodes were processed by graphlib");
@@ -453,7 +519,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));
@@ -644,8 +712,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);
@@ -685,8 +754,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);
@@ -771,7 +841,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);
@@ -794,6 +866,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 = core.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;
@@ -803,6 +919,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();
   }
@@ -814,14 +940,30 @@ class ComputeCtx {
       rules,
       ...view
     } = this.view;
-    const viewPredicates = rules.filter(core.isViewRulePredicate);
+    const viewPredicates = rules.filter(remeda.anyPass([core.isViewRulePredicate, core.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) {
@@ -830,25 +972,37 @@ class ComputeCtx {
       const target = nodesMap.get(edge.target);
       core.invariant(source, `Source node ${edge.source} not found`);
       core.invariant(target, `Target node ${edge.target} not found`);
-      while (edge.parent && !nodesMap.has(edge.parent)) {
-        edge.parent = core.parentFqn(edge.parent);
-      }
+      const sourceAncestors = ancestorsOf(source);
+      const targetAncestors = ancestorsOf(target);
+      const edgeParent = remeda.last(
+        core.commonHead(
+          remeda.reverse(sourceAncestors),
+          remeda.reverse(targetAncestors)
+        )
+      );
+      edge.parent = edgeParent?.id ?? null;
       source.outEdges.push(edge.id);
       target.inEdges.push(edge.id);
-      for (const sourceAncestor of core.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 core.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) => core.nonNullable(nodesMap.get(e.id), `Node ${e.id} not found in nodesMap`));
+    if (this.groups.length > 0) {
+      initialSort = remeda.concat(
+        this.groups.map((g) => core.nonNullable(nodesMap.get(g.id), `Node ${g.id} not found in nodesMap`)),
+        initialSort
+      );
+    }
     const nodes = applyCustomElementProperties(
       rules,
       applyViewRuleStyles(
@@ -994,6 +1148,7 @@ class ComputeCtx {
     return this.ctxEdges;
   }
   addEdges(edges) {
+    const added = [];
     for (const e of edges) {
       if (!remeda.hasAtLeast(e.relations, 1)) {
         continue;
@@ -1003,10 +1158,13 @@ class ComputeCtx {
       );
       if (existing) {
         existing.relations = remeda.unique([...existing.relations, ...e.relations]);
+        added.push(existing);
         continue;
       }
+      added.push(e);
       this.ctxEdges.push(e);
     }
+    return added;
   }
   /**
    * Add element explicitly
@@ -1014,6 +1172,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);
     }
@@ -1025,7 +1191,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) {
@@ -1033,12 +1205,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;
@@ -1070,11 +1241,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));
       }
     }
   }
@@ -1082,6 +1257,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
@@ -1124,8 +1302,41 @@ class ComputeCtx {
       return acc;
     }, []);
   }
+  cleanGroupElements() {
+    const unprocessed = new Set(remeda.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 (core.isViewRuleGroup(rule)) {
+        const parent = remeda.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) {