@likec4/language-server 1.15.0 → 1.16.0

package/src/model-graph/compute-view/compute.ts

@@ -8,6 +8,7 @@ import {
   ElementKind,
   type ElementPredicateExpression,
   type ElementView,
+  type Fqn,
   type NodeId,
   type NonEmptyArray,
   type Relation,
@@ -54,6 +55,7 @@ import {
   sort,
   unique
 } from 'remeda'
+import { resolveGlobalRulesInElementView } from '../../view-utils/resolve-global-rules'
 import { calcViewLayoutHash } from '../../view-utils/view-hash'
 import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
@@ -179,6 +181,29 @@ export class ComputeCtx {
 
   protected get activeGroup() {
     return this.activeGroupStack[0] ?? this.__rootGroup
+  } 
+
+  protected get includedElements() {
+    return new Set([
+      ...this.explicits,
+      ...this.ctxEdges.flatMap(e => [e.source, e.target])
+    ]) as ReadonlySet<Element>
+  }
+
+  protected get resolvedElements() {
+    return new Set([
+      ...this.explicits,
+      ...this.implicits,
+      ...this.ctxEdges.flatMap(e => [e.source, e.target])
+    ]) as ReadonlySet<Element>
+  }
+
+  protected get edges() {
+    return this.ctxEdges
+  }
+
+  protected get root() {
+    return isScopedElementView(this.view) ? this.view.viewOf : null
   }
 
   public static elementView(view: ElementView, graph: LikeC4ModelGraph) {
@@ -194,10 +219,12 @@ export class ComputeCtx {
     this.reset()
     const {
       docUri: _docUri, // exclude docUri
-      rules,
+      rules: _rules, // exclude rules
       ...view
     } = this.view
 
+    const rules = resolveGlobalRulesInElementView(this.view, this.graph.globals)
+
     const viewPredicates = rules.filter(anyPass([isViewRulePredicate, isViewRuleGroup])) as Array<
       ViewRulePredicate | ViewRuleGroup
     >
@@ -213,56 +240,10 @@ export class ComputeCtx {
     const elements = [...this.includedElements]
     const nodesMap = buildComputeNodes(elements, this.groups)
 
-    const ancestorsOf = (node: ComputedNode) => {
-      const ancestors = [] as ComputedNode[]
-      let parent = node.parent
-      while (parent) {
-        const parentNode = nodesMap.get(parent)
-        if (!parentNode) {
-          break
-        }
-        ancestors.push(parentNode)
-        parent = parentNode.parent
-      }
-      return ancestors
-    }
-
-    const edgesMap = new Map<EdgeId, ComputedEdge>()
     const edges = this.computeEdges()
-    for (const edge of edges) {
-      edgesMap.set(edge.id, edge)
-      const source = nodesMap.get(edge.source)
-      const target = nodesMap.get(edge.target)
-      invariant(source, `Source node ${edge.source} not found`)
-      invariant(target, `Target node ${edge.target} not found`)
-      // These ancestors are reversed: from bottom to top
-      const sourceAncestors = ancestorsOf(source)
-      const targetAncestors = ancestorsOf(target)
+    const edgesMap = new Map<EdgeId, ComputedEdge>(edges.map(edge => [edge.id, edge]))
 
-      const edgeParent = last(
-        commonHead(
-          reverse(sourceAncestors),
-          reverse(targetAncestors)
-        )
-      )
-      edge.parent = edgeParent?.id ?? null
-      source.outEdges.push(edge.id)
-      target.inEdges.push(edge.id)
-      // Process edge source ancestors
-      for (const sourceAncestor of sourceAncestors) {
-        if (sourceAncestor === edgeParent) {
-          break
-        }
-        sourceAncestor.outEdges.push(edge.id)
-      }
-      // Process target hierarchy
-      for (const targetAncestor of targetAncestors) {
-        if (targetAncestor === edgeParent) {
-          break
-        }
-        targetAncestor.inEdges.push(edge.id)
-      }
-    }
+    this.linkNodesAndEdges(nodesMap, edges)
 
     // nodesMap sorted hierarchically,
     // but we need to keep the initial sort
@@ -312,10 +293,6 @@ export class ComputeCtx {
     })
   }
 
-  protected get root() {
-    return isScopedElementView(this.view) ? this.view.viewOf : null
-  }
-
   protected computeEdges(): ComputedEdge[] {
     return this.ctxEdges.map((e): ComputedEdge => {
       invariant(hasAtLeast(e.relations, 1), 'Edge must have at least one relation')
@@ -428,23 +405,40 @@ export class ComputeCtx {
     })
   }
 
-  protected get includedElements() {
-    return new Set([
-      ...this.explicits,
-      ...this.ctxEdges.flatMap(e => [e.source, e.target])
-    ]) as ReadonlySet<Element>
-  }
-
-  protected get resolvedElements() {
-    return new Set([
-      ...this.explicits,
-      ...this.implicits,
-      ...this.ctxEdges.flatMap(e => [e.source, e.target])
-    ]) as ReadonlySet<Element>
-  }
+  protected linkNodesAndEdges(nodesMap: ReadonlyMap<Fqn, ComputedNode>, edges: ComputedEdge[]) {
+    for (const edge of edges) {
+      const source = nodesMap.get(edge.source)
+      const target = nodesMap.get(edge.target)
+      invariant(source, `Source node ${edge.source} not found`)
+      invariant(target, `Target node ${edge.target} not found`)
+      // These ancestors are reversed: from bottom to top
+      const sourceAncestors = this.ancestorsOf(source, nodesMap)
+      const targetAncestors = this.ancestorsOf(target, nodesMap)
 
-  protected get edges() {
-    return this.ctxEdges
+      const edgeParent = last(
+        commonHead(
+          reverse(sourceAncestors),
+          reverse(targetAncestors)
+        )
+      )
+      edge.parent = edgeParent?.id ?? null
+      source.outEdges.push(edge.id)
+      target.inEdges.push(edge.id)
+      // Process edge source ancestors
+      for (const sourceAncestor of sourceAncestors) {
+        if (sourceAncestor === edgeParent) {
+          break
+        }
+        sourceAncestor.outEdges.push(edge.id)
+      }
+      // Process target hierarchy
+      for (const targetAncestor of targetAncestors) {
+        if (targetAncestor === edgeParent) {
+          break
+        }
+        targetAncestor.inEdges.push(edge.id)
+      }
+    }
   }
 
   protected addEdges(edges: ComputeCtx.Edge[]) {
@@ -539,9 +533,6 @@ export class ComputeCtx {
       }),
       filter(isNonNull)
     )
-    if (excludedImplicits.size === 0) {
-      return
-    }
     this.ctxEdges = ctxEdges
     const remaining = this.includedElements
     if (remaining.size === 0) {
@@ -755,6 +746,20 @@ export class ComputeCtx {
     nonexhaustive(expr)
   }
 
+  private ancestorsOf(node: ComputedNode, nodesMap: ReadonlyMap<Fqn, ComputedNode>): ComputedNode[] {
+    const ancestors = [] as ComputedNode[]
+    let parent = node.parent
+    while (parent) {
+      const parentNode = nodesMap.get(parent)
+      if (!parentNode) {
+        break
+      }
+      ancestors.push(parentNode)
+      parent = parentNode.parent
+    }
+    return ancestors
+  }
+
   protected getEdgeLabel(
     relation: {
       title: string

package/src/model-graph/dynamic-view/compute.ts

@@ -26,6 +26,7 @@ import {
   StepEdgeId
 } from '@likec4/core'
 import { filter, flatMap, hasAtLeast, isTruthy, map, omit, only, pipe, unique } from 'remeda'
+import { resolveGlobalRulesInDynamicView } from '../../view-utils/resolve-global-rules'
 import { calcViewLayoutHash } from '../../view-utils/view-hash'
 import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
@@ -111,7 +112,7 @@ export class DynamicViewComputeCtx {
   protected compute(): ComputedDynamicView {
     const {
       docUri: _docUri, // exclude docUri
-      rules,
+      rules: _rules, // exclude rules
       steps: viewSteps,
       ...view
     } = this.view
@@ -133,6 +134,8 @@ export class DynamicViewComputeCtx {
       stepNum++
     }
 
+    const rules = resolveGlobalRulesInDynamicView(this.view, this.graph.globals)
+
     for (const rule of rules) {
       if (isDynamicViewIncludeRule(rule)) {
         for (const expr of rule.include) {

package/src/model-graph/utils/applyCustomRelationProperties.ts

@@ -1,39 +1,8 @@
-import type { ComputedEdge, ComputedNode, Element, ViewRule } from '@likec4/core'
-import { Expr, nonexhaustive } from '@likec4/core'
-import { isNullish, omitBy } from 'remeda'
+import type { ComputedEdge, ComputedNode, ViewRule } from '@likec4/core'
+import { Expr } from '@likec4/core'
+import { isNullish, omitBy, pick } from 'remeda'
 import { flattenGroupRules } from './applyCustomElementProperties'
-import { elementExprToPredicate } from './elementExpressionToPredicate'
-
-function relationExpressionToPredicates(
-  expr: Expr.RelationExpression | Expr.RelationWhereExpr
-): (edge: { source: Element; target: Element }) => boolean {
-  switch (true) {
-    case Expr.isRelationWhere(expr):
-      return relationExpressionToPredicates(expr.where.expr)
-    case Expr.isRelation(expr): {
-      const isSource = elementExprToPredicate(expr.source)
-      const isTarget = elementExprToPredicate(expr.target)
-      return edge => {
-        return (isSource(edge.source) && isTarget(edge.target))
-          || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
-      }
-    }
-    case Expr.isInOut(expr): {
-      const isInOut = elementExprToPredicate(expr.inout)
-      return edge => isInOut(edge.source) || isInOut(edge.target)
-    }
-    case Expr.isIncoming(expr): {
-      const isTarget = elementExprToPredicate(expr.incoming)
-      return edge => isTarget(edge.target)
-    }
-    case Expr.isOutgoing(expr): {
-      const isSource = elementExprToPredicate(expr.outgoing)
-      return edge => isSource(edge.source)
-    }
-    default:
-      nonexhaustive(expr)
-  }
-}
+import { relationExpressionToPredicates } from './relationExpressionToPredicates'
 
 export function applyCustomRelationProperties(
   _rules: ViewRule[],
@@ -58,12 +27,12 @@ export function applyCustomRelationProperties(
       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
         }
       }
     })

package/src/model-graph/utils/applyViewRuleStyles.ts

@@ -13,10 +13,6 @@ export function applyViewRuleStyles(_rules: ViewRule[], nodes: ComputedNode[]) {
   for (const rule of rules) {
     const predicates = [] as Predicate<ComputedNode>[]
     for (const target of rule.targets) {
-      if (Expr.isWildcard(target)) {
-        predicates.push(() => true)
-        break
-      }
       predicates.push(elementExprToPredicate(target) as Predicate<ComputedNode>)
     }
     pipe(

package/src/model-graph/utils/relationExpressionToPredicates.ts

@@ -0,0 +1,43 @@
+import type { Element, Relation } from '@likec4/core'
+import { Expr, nonexhaustive, whereOperatorAsPredicate } from '@likec4/core'
+import { elementExprToPredicate } from './elementExpressionToPredicate'
+
+type Predicate<T> = (x: T) => boolean
+export type FilterableEdge = Pick<Relation, 'kind' | 'tags'> & {
+  source: Element
+  target: Element
+}
+
+export function relationExpressionToPredicates<T extends FilterableEdge>(
+  expr: Expr.RelationExpression | Expr.RelationWhereExpr
+): Predicate<T> {
+  switch (true) {
+    case Expr.isRelationWhere(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)
+      return edge => {
+        return (isSource(edge.source) && isTarget(edge.target))
+          || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
+      }
+    }
+    case Expr.isInOut(expr): {
+      const isInOut = elementExprToPredicate(expr.inout)
+      return edge => isInOut(edge.source) || isInOut(edge.target)
+    }
+    case Expr.isIncoming(expr): {
+      const isTarget = elementExprToPredicate(expr.incoming)
+      return edge => isTarget(edge.target)
+    }
+    case Expr.isOutgoing(expr): {
+      const isSource = elementExprToPredicate(expr.outgoing)
+      return edge => isSource(edge.source)
+    }
+    default:
+      nonexhaustive(expr)
+  }
+}

package/src/references/scope-computation.ts

@@ -69,6 +69,16 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     if (isNullish(globals) || globals.length === 0) {
       return
     }
+    for (const globalPredicateAst of globals.flatMap(g => g.predicates)) {
+      try {
+        const id = globalPredicateAst
+        if (isTruthy(id.name)) {
+          docExports.push(this.descriptions.createDescription(id, id.name, document))
+        }
+      } catch (e) {
+        logError(e)
+      }
+    }
     for (const globalStyleAst of globals.flatMap(g => g.styles)) {
       try {
         const id = globalStyleAst.id

package/src/validation/index.ts

@@ -8,6 +8,7 @@ import { iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChe
 import { relationBodyChecks, relationChecks } from './relation'
 import {
   elementKindChecks,
+  globalPredicateChecks,
   globalsChecks,
   globalStyleIdChecks,
   modelRuleChecks,
@@ -34,6 +35,8 @@ export function registerValidationChecks(services: LikeC4Services) {
     SpecificationRule: specificationRuleChecks(services),
     Model: modelRuleChecks(services),
     Globals: globalsChecks(services),
+    GlobalPredicateGroup: globalPredicateChecks(services),
+    GlobalDynamicPredicateGroup: globalPredicateChecks(services),
     GlobalStyleId: globalStyleIdChecks(services),
     DynamicViewStep: dynamicViewStep(services),
     LikeC4View: viewChecks(services),

package/src/validation/specification.ts

@@ -130,6 +130,27 @@ export const relationshipChecks = (
   }
 }
 
+export const globalPredicateChecks = (
+  services: LikeC4Services
+): ValidationCheck<ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup> => {
+  const index = services.shared.workspace.IndexManager
+  return (node, accept) => {
+    const predicateGroups = index.allElements(ast.GlobalPredicateGroup)
+    const dynamicPredicateGroups = index.allElements(ast.GlobalDynamicPredicateGroup)
+    const sameName = predicateGroups
+      .concat(dynamicPredicateGroups)
+      .filter(s => s.name === node.name)
+      .limit(2)
+      .count()
+    if (sameName > 1) {
+      accept('error', `Duplicate GlobalPredicateGroup or GlobalDynamicPredicateGroup name '${node.name}'`, {
+        node: node,
+        property: 'name'
+      })
+    }
+  }
+}
+
 export const globalStyleIdChecks = (
   services: LikeC4Services
 ): ValidationCheck<ast.GlobalStyleId> => {

package/src/view-utils/index.ts

@@ -1,4 +1,3 @@
 export * from './assignNavigateTo'
 export * from './resolve-extended-views'
-export * from './resolve-global-rules'
 export * from './resolve-relative-paths'

package/src/view-utils/resolve-global-rules.ts

@@ -1,72 +1,88 @@
 import {
   type DynamicView,
+  type DynamicViewRule,
   type ElementView,
-  type GlobalStyle,
-  type GlobalStyleID,
   isDynamicView,
   isElementView,
+  isViewRuleGlobalPredicateRef,
   isViewRuleGlobalStyle,
-  type LikeC4View,
-  nonexhaustive
+  type ModelGlobals,
+  nonexhaustive,
+  type ViewRule,
+  type ViewRuleGlobalPredicateRef,
+  type ViewRuleGlobalStyle
 } from '@likec4/core'
 import { logger } from '@likec4/log'
+import { isNullish } from 'remeda'
 
-export function resolveGlobalRules(
-  view: LikeC4View,
-  globalStyles: Record<GlobalStyleID, GlobalStyle>
-): LikeC4View {
+export function resolveGlobalRules<V extends DynamicView | ElementView>(
+  view: V,
+  globals: ModelGlobals
+): V {
   if (isElementView(view)) {
-    return resolveGlobalStyleInElementView(view, globalStyles)
+    return {
+      ...view,
+      rules: resolveGlobalRulesInElementView(view, globals)
+    }
   } else if (isDynamicView(view)) {
-    return resolveGlobalStyleInDynamicView(view, globalStyles)
+    return {
+      ...view,
+      rules: resolveGlobalRulesInDynamicView(view, globals)
+    }
   }
   nonexhaustive(view)
 }
 
-function resolveGlobalStyleInElementView(
+type ViewRuleGlobal = ViewRuleGlobalPredicateRef | ViewRuleGlobalStyle
+
+export function resolveGlobalRulesInElementView(
   view: ElementView,
-  globalStyles: Record<GlobalStyleID, GlobalStyle>
-): LikeC4View {
-  const resolvedRules = view.rules
-    .flatMap(rule => {
-      if (isViewRuleGlobalStyle(rule)) {
-        const globalStyle = globalStyles[rule.styleId]
-        if (globalStyle === undefined) {
-          logger.warn(`Global style not found: ${rule.styleId}`)
-          return []
-        }
-        return globalStyle.styles
-      } else {
-        return rule
+  globals: ModelGlobals
+): Array<Exclude<ViewRule, ViewRuleGlobal>> {
+  return view.rules.reduce((acc, rule) => {
+    if (isViewRuleGlobalPredicateRef(rule)) {
+      const globalPredicates = globals.predicates[rule.predicateId]
+      if (isNullish(globalPredicates)) {
+        logger.warn(`Global predicate not found: ${rule.predicateId}`)
+        return acc
       }
-    })
-
-  return {
-    ...view,
-    rules: resolvedRules
-  }
+      return acc.concat(globalPredicates)
+    }
+    if (isViewRuleGlobalStyle(rule)) {
+      const globalStyles = globals.styles[rule.styleId]
+      if (isNullish(globalStyles)) {
+        logger.warn(`Global style not found: ${rule.styleId}`)
+        return acc
+      }
+      return acc.concat(globalStyles)
+    }
+    acc.push(rule)
+    return acc
+  }, [] as Array<Exclude<ViewRule, ViewRuleGlobal>>)
 }
 
-function resolveGlobalStyleInDynamicView(
+export function resolveGlobalRulesInDynamicView(
   view: DynamicView,
-  globalStyles: Record<GlobalStyleID, GlobalStyle>
-): LikeC4View {
-  const resolvedRules = view.rules
-    .flatMap(rule => {
-      if (isViewRuleGlobalStyle(rule)) {
-        const globalStyle = globalStyles[rule.styleId]
-        if (globalStyle === undefined) {
-          logger.warn(`Global style not found: ${rule.styleId}`)
-          return []
-        }
-        return globalStyle.styles
-      } else {
-        return rule
+  globals: ModelGlobals
+): Array<Exclude<DynamicViewRule, ViewRuleGlobal>> {
+  return view.rules.reduce((acc, rule) => {
+    if (isViewRuleGlobalPredicateRef(rule)) {
+      const globalPredicates = globals.dynamicPredicates[rule.predicateId]
+      if (isNullish(globalPredicates)) {
+        logger.warn(`Global predicate not found: ${rule.predicateId}`)
+        return acc
       }
-    })
-
-  return {
-    ...view,
-    rules: resolvedRules
-  }
+      return acc.concat(globalPredicates)
+    }
+    if (isViewRuleGlobalStyle(rule)) {
+      const globalStyles = globals.styles[rule.styleId]
+      if (isNullish(globalStyles)) {
+        logger.warn(`Global style not found: ${rule.styleId}`)
+        return acc
+      }
+      return acc.concat(globalStyles)
+    }
+    acc.push(rule)
+    return acc
+  }, [] as Array<Exclude<DynamicViewRule, ViewRuleGlobal>>)
 }