@likec4/language-server 1.4.0 → 1.6.0

package/src/model/model-builder.ts

@@ -2,9 +2,9 @@ import {
   type c4,
   compareByFqnHierarchically,
   isElementView,
-  isStrictElementView,
+  isScopedElementView,
   parentFqn,
-  type StrictElementView,
+  type ScopedElementView,
   type ViewID
 } from '@likec4/core'
 import { deepEqual as eq } from 'fast-equals'
@@ -26,7 +26,7 @@ import {
   sort,
   values
 } from 'remeda'
-import { type CancellationToken, Disposable } from 'vscode-languageserver'
+import { type CancellationToken, Disposable } from 'vscode-languageserver-protocol'
 import type {
   ParsedAstElement,
   ParsedAstRelation,
@@ -107,7 +107,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
 
   const elements = pipe(
     docs,
-    flatMap(d => d.c4Elements.map(toModelElement(d))),
+    flatMap(d => map(d.c4Elements, toModelElement(d))),
     filter(isTruthy),
     sort(compareByFqnHierarchically),
     reduce(
@@ -140,10 +140,13 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
       ...model
     }: ParsedAstRelation): c4.Relation | null => {
       if (isNullish(elements[source]) || isNullish(elements[target])) {
+        logger.warn(
+          `Invalid relation ${id}, source: ${source}(${!!elements[source]}), target: ${target}(${!!elements[target]})`
+        )
         return null
       }
 
-      if (!!kind && kind in c4Specification.relationships) {
+      if (!isNullish(kind) && kind in c4Specification.relationships) {
         return {
           ...(links && { links: resolveLinks(doc, links) }),
           ...c4Specification.relationships[kind],
@@ -165,14 +168,15 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
   }
 
   const relations = pipe(
-    flatMap(docs, d => map(d.c4Relations, toModelRelation(d))),
+    docs,
+    flatMap(d => map(d.c4Relations, toModelRelation(d))),
     filter(isTruthy),
     mapToObj(r => [r.id, r])
   )
 
   const toC4View = (doc: LangiumDocument) => {
     const docUri = doc.uri.toString()
-    return (parsedAstView: ParsedAstView): c4.View => {
+    return (parsedAstView: ParsedAstView): c4.LikeC4View => {
       let {
         id,
         title,
@@ -188,7 +192,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
       } = parsedAstView
 
       if (parsedAstView.__ === 'element' && isNullish(title) && 'viewOf' in parsedAstView) {
-        title ??= elements[parsedAstView.viewOf]?.title ?? null
+        title = elements[parsedAstView.viewOf]?.title ?? null
       }
 
       if (isNullish(title) && id === 'index') {
@@ -359,7 +363,7 @@ export class LikeC4ModelBuilder {
         }
 
         const allElementViews = values(model.views).filter(
-          (v): v is StrictElementView => isStrictElementView(v) && v.id !== viewId
+          (v): v is ScopedElementView => isScopedElementView(v) && v.id !== viewId
         )
 
         let computedView = result.view

package/src/model/model-locator.ts

@@ -33,18 +33,18 @@ export class LikeC4ModelLocator {
     return doc.c4Elements.find(e => e.id === fqn) ?? null
   }
 
-  public locateElement(fqn: c4.Fqn, property = 'name'): Location | null {
+  public locateElement(fqn: c4.Fqn, _property = 'name'): Location | null {
     const entry = this.fqnIndex.byFqn(fqn).head()
     if (!entry) {
       return null
     }
-    const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode
-    if (!propertyNode) {
-      return null
-    }
+    // const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode
+    // if (!propertyNode) {
+    //   return null
+    // }
     return {
-      uri: entry.doc.uri.toString(),
-      range: propertyNode.range
+      uri: entry.documentUri.toString(),
+      range: entry.nameSegment?.range!
     }
   }
 

package/src/model/model-parser.ts

@@ -1,7 +1,7 @@
 import { type c4, InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
 import type { AstNode, LangiumDocument } from 'langium'
 import { AstUtils, CstUtils } from 'langium'
-import { isTruthy } from 'remeda'
+import { isTruthy, mapToObj } from 'remeda'
 import stripIndent from 'strip-indent'
 import type {
   ChecksFromDiagnostics,
@@ -37,14 +37,14 @@ const { getDocument } = AstUtils
 export type ModelParsedListener = () => void
 
 function toSingleLine<T extends string | undefined>(str: T): T {
-  return (str ? removeIndent(str).split('\n').join(' ') : undefined) as T
+  return (isTruthy(str) ? removeIndent(str).split('\n').join(' ') : undefined) as T
 }
 
 function removeIndent<T extends string | undefined>(str: T): T {
-  return (str ? stripIndent(str).trim() : undefined) as T
+  return (isTruthy(str) ? stripIndent(str).trim() : undefined) as T
 }
 
-type IsValidFn = ChecksFromDiagnostics['isValid']
+export type IsValidFn = ChecksFromDiagnostics['isValid']
 
 export class LikeC4ModelParser {
   private fqnIndex: FqnIndex
@@ -142,14 +142,23 @@ export class LikeC4ModelParser {
 
     let [title, description, technology] = astNode.props ?? []
 
-    const bodyProps = astNode.body?.props.filter(ast.isElementStringProperty) ?? []
+    const bodyProps = mapToObj(astNode.body?.props.filter(ast.isElementStringProperty) ?? [], p => [p.key, p.value])
 
-    title = toSingleLine(title ?? bodyProps.find(p => p.key === 'title')?.value)
-    description = removeIndent(description ?? bodyProps.find(p => p.key === 'description')?.value)
-    technology = toSingleLine(technology ?? bodyProps.find(p => p.key === 'technology')?.value)
+    title = toSingleLine(title ?? bodyProps.title)
+    description = removeIndent(bodyProps.description ?? description)
+    technology = toSingleLine(bodyProps.technology ?? technology)
 
     const links = astNode.body?.props.filter(ast.isLinkProperty).map(p => p.value)
 
+    // Property has higher priority than from style
+    const iconProp = astNode.body?.props.find(ast.isIconProperty)
+    if (iconProp) {
+      const value = iconProp.libicon?.ref?.name ?? iconProp.value
+      if (isTruthy(value)) {
+        style.icon = value as c4.IconUrl
+      }
+    }
+
     return {
       id,
       kind,
@@ -171,7 +180,7 @@ export class LikeC4ModelParser {
     const links = astNode.body?.props.filter(ast.isLinkProperty).map(p => p.value)
     const kind = astNode.kind?.ref?.name as c4.RelationshipKind
     const astPath = this.getAstNodePath(astNode)
-    const title = toSingleLine(
+    const title = removeIndent(
       astNode.title ?? astNode.body?.props.find((p): p is ast.RelationStringProperty => p.key === 'title')?.value
     ) ?? ''
     const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty)
@@ -209,39 +218,70 @@ export class LikeC4ModelParser {
     }
   }
 
-  private parseElementExpr(astNode: ast.ElementExpr): c4.ElementExpression {
-    if (ast.isWildcardExpr(astNode)) {
+  // TODO validate view rules
+  private parseViewRulePredicate(astNode: ast.ViewRulePredicate, _isValid: IsValidFn): c4.ViewRulePredicate {
+    const exprs = [] as c4.Expression[]
+    let exprNode: ast.Expressions | undefined = astNode.exprs
+    while (exprNode) {
+      try {
+        if (isTruthy(exprNode.value)) {
+          exprs.unshift(this.parseExpression(exprNode.value))
+        }
+      } catch (e) {
+        logWarnError(e)
+      }
+      exprNode = exprNode.prev
+    }
+    return ast.isIncludePredicate(astNode) ? { include: exprs } : { exclude: exprs }
+  }
+
+  private parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[] {
+    const exprs = [] as c4.ElementExpression[]
+    let iter: ast.ElementExpressionsIterator | undefined = astNode
+    while (iter) {
+      try {
+        exprs.unshift(this.parseElementExpr(iter.value))
+      } catch (e) {
+        logWarnError(e)
+      }
+      iter = iter.prev
+    }
+    return exprs
+  }
+
+  private parseElementExpr(astNode: ast.ElementExpression): c4.ElementExpression {
+    if (ast.isWildcardExpression(astNode)) {
       return {
         wildcard: true
       }
     }
-    if (ast.isElementKindExpr(astNode)) {
-      // invariant(astNode.kind.ref, 'ElementKindExpr kind is not resolved: ' + astNode.$cstNode?.text)
+    if (ast.isElementKindExpression(astNode)) {
+      invariant(astNode.kind, 'ElementKindExpr kind is not resolved: ' + astNode.$cstNode?.text)
       return {
         elementKind: astNode.kind.$refText as c4.ElementKind,
         isEqual: astNode.isEqual
       }
     }
-    if (ast.isElementTagExpr(astNode)) {
+    if (ast.isElementTagExpression(astNode)) {
+      invariant(astNode.tag, 'ElementTagExpr tag is not resolved: ' + astNode.$cstNode?.text)
       let elementTag = astNode.tag.$refText
       if (elementTag.startsWith('#')) {
         elementTag = elementTag.slice(1)
       }
-      // invariant(astNode.tag.ref, 'ElementTagExpr tag is not resolved: ' + astNode.$cstNode?.text)
       return {
         elementTag: elementTag as c4.Tag,
         isEqual: astNode.isEqual
       }
     }
-    if (ast.isExpandElementExpr(astNode)) {
-      const elementNode = elementRef(astNode.parent)
-      invariant(elementNode, 'Element not found ' + astNode.parent.$cstNode?.text)
+    if (ast.isExpandElementExpression(astNode)) {
+      const elementNode = elementRef(astNode.expand)
+      invariant(elementNode, 'Element not found ' + astNode.expand.$cstNode?.text)
       const expanded = this.resolveFqn(elementNode)
       return {
         expanded
       }
     }
-    if (ast.isDescedantsExpr(astNode)) {
+    if (ast.isElementDescedantsExpression(astNode)) {
       const elementNode = elementRef(astNode.parent)
       invariant(elementNode, 'Element not found ' + astNode.parent.$cstNode?.text)
       const element = this.resolveFqn(elementNode)
@@ -261,20 +301,25 @@ export class LikeC4ModelParser {
     nonexhaustive(astNode)
   }
 
-  private parseCustomElementExpr(astNode: ast.CustomElementExpr): c4.CustomElementExpr {
+  private parseCustomElementExpr(astNode: ast.CustomElementExpression): c4.CustomElementExpr {
     let targetRef
-    if (ast.isElementRef(astNode.target)) {
-      targetRef = astNode.target
-    } else if (ast.isExpandElementExpr(astNode.target)) {
-      targetRef = astNode.target.parent
-    } else {
-      invariant(false, 'ElementRef expected as target of custom element')
-    }
-    // invariant(ast.isElementRef(astNode.target), 'ElementRef expected as target of custom element')
+    switch (true) {
+      case ast.isElementRef(astNode.target):
+        targetRef = astNode.target
+        break
+      case ast.isExpandElementExpression(astNode.target):
+        targetRef = astNode.target.expand
+        break
+      case ast.isElementDescedantsExpression(astNode.target):
+        targetRef = astNode.target.parent
+        break
+      default:
+        throw new Error('Unsupported target of custom element')
+    }
     const elementNode = elementRef(targetRef)
     invariant(elementNode, 'element not found: ' + astNode.$cstNode?.text)
     const element = this.resolveFqn(elementNode)
-    const props = astNode.body?.props ?? []
+    const props = astNode.custom.props ?? []
     return props.reduce(
       (acc, prop) => {
         if (ast.isNavigateToProperty(prop)) {
@@ -290,7 +335,10 @@ export class LikeC4ModelParser {
           return acc
         }
         if (ast.isIconProperty(prop)) {
-          acc.custom[prop.key] = prop.value as c4.IconUrl
+          const value = prop.libicon?.ref?.name ?? prop.value
+          if (isTruthy(value)) {
+            acc.custom[prop.key] = value as c4.IconUrl
+          }
           return acc
         }
         if (ast.isColorProperty(prop)) {
@@ -320,54 +368,90 @@ export class LikeC4ModelParser {
     )
   }
 
-  private parsePredicateExpr(astNode: ast.ViewRulePredicateExpr): c4.Expression {
-    if (ast.isRelationExpr(astNode)) {
+  private parseExpression(astNode: ast.Expression): c4.Expression {
+    if (ast.isCustomRelationExpression(astNode)) {
+      return this.parseCustomRelationExpr(astNode)
+    }
+    if (ast.isCustomElementExpression(astNode)) {
+      return this.parseCustomElementExpr(astNode)
+    }
+    if (ast.isElementExpression(astNode)) {
+      return this.parseElementExpr(astNode)
+    }
+    if (ast.isRelationExpression(astNode)) {
+      return this.parseRelationExpr(astNode)
+    }
+    nonexhaustive(astNode)
+  }
+
+  private parseCustomRelationExpr(astNode: ast.CustomRelationExpression): c4.CustomRelationExpr {
+    const relation = this.parseRelationExpr(astNode.relation)
+    const props = astNode.custom.props ?? []
+    return props.reduce(
+      (acc, prop) => {
+        if (ast.isRelationStringProperty(prop)) {
+          const value = removeIndent(prop.value)
+          if (isTruthy(value)) {
+            acc.customRelation['title'] = value
+          }
+          return acc
+        }
+        if (ast.isArrowProperty(prop)) {
+          acc.customRelation[prop.key] = prop.value
+          return acc
+        }
+        if (ast.isColorProperty(prop)) {
+          acc.customRelation[prop.key] = prop.value
+          return acc
+        }
+        if (ast.isLineProperty(prop)) {
+          acc.customRelation[prop.key] = prop.value
+          return acc
+        }
+        nonexhaustive(prop)
+      },
+      {
+        customRelation: {
+          relation
+        }
+      } as c4.CustomRelationExpr
+    )
+  }
+
+  private parseRelationExpr(astNode: ast.RelationExpression): c4.RelationExpression {
+    if (ast.isDirectedRelationExpression(astNode)) {
       return {
-        source: this.parseElementExpr(astNode.source),
+        source: this.parseElementExpr(astNode.source.from),
         target: this.parseElementExpr(astNode.target),
-        isBidirectional: astNode.isBidirectional
+        isBidirectional: astNode.source.isBidirectional
       }
     }
-    if (ast.isInOutExpr(astNode)) {
+    if (ast.isInOutRelationExpression(astNode)) {
       return {
         inout: this.parseElementExpr(astNode.inout.to)
       }
     }
-    if (ast.isOutgoingExpr(astNode)) {
+    if (ast.isOutgoingRelationExpression(astNode)) {
       return {
         outgoing: this.parseElementExpr(astNode.from)
       }
     }
-    if (ast.isIncomingExpr(astNode)) {
+    if (ast.isIncomingRelationExpression(astNode)) {
       return {
         incoming: this.parseElementExpr(astNode.to)
       }
     }
-    if (ast.isCustomElementExpr(astNode)) {
-      return this.parseCustomElementExpr(astNode)
-    }
-    if (ast.isElementExpr(astNode)) {
-      return this.parseElementExpr(astNode)
-    }
     nonexhaustive(astNode)
   }
 
   private parseViewRule(astRule: ast.ViewRule, isValid: IsValidFn): c4.ViewRule {
-    if (ast.isIncludePredicate(astRule) || ast.isExcludePredicate(astRule)) {
-      const exprs = astRule.expressions.flatMap(n => {
-        try {
-          return isValid(n) ? this.parsePredicateExpr(n) : []
-        } catch (e) {
-          logWarnError(e)
-          return []
-        }
-      })
-      return ast.isIncludePredicate(astRule) ? { include: exprs } : { exclude: exprs }
+    if (ast.isViewRulePredicate(astRule)) {
+      return this.parseViewRulePredicate(astRule, isValid)
     }
     if (ast.isViewRuleStyle(astRule)) {
-      const styleProps = toElementStyle(astRule.styleprops)
+      const styleProps = toElementStyle(astRule.props)
       return {
-        targets: astRule.targets.map(n => this.parseElementExpr(n)),
+        targets: this.parseElementExpressionsIterator(astRule.target),
         style: {
           ...styleProps
         }
@@ -398,18 +482,22 @@ export class LikeC4ModelParser {
     if (!targetEl) {
       throw new Error('Invalid reference to target')
     }
+    const title = removeIndent(node.title) ?? null
     let source = this.resolveFqn(sourceEl)
     let target = this.resolveFqn(targetEl)
     if (node.isBackward) {
-      ;[source, target] = [target, source]
+      return {
+        source: target,
+        target: source,
+        title,
+        isBackward: true
+      }
     }
 
-    const title = toSingleLine(node.title) ?? null
     return {
       source,
       target,
-      title,
-      isBackward: node.isBackward
+      title
     }
   }
 
@@ -518,15 +606,24 @@ export class LikeC4ModelParser {
         try {
           if (ast.isDynamicViewRulePredicate(n)) {
             const include = [] as (c4.ElementExpression | c4.CustomElementExpr)[]
-            for (const expr of n.expressions) {
-              if (ast.isElementExpr(expr)) {
-                include.push(this.parseElementExpr(expr))
-                continue
-              }
-              if (ast.isCustomElementExpr(expr)) {
-                include.push(this.parseCustomElementExpr(expr))
-                continue
+            let iter: ast.DynamicViewRulePredicateIterator | undefined = n.exprs
+            while (iter) {
+              try {
+                switch (true) {
+                  case ast.isElementExpression(iter.value):
+                    isValid(iter.value) && include.unshift(this.parseElementExpr(iter.value))
+                    break
+
+                  case ast.isCustomElementExpression(iter.value):
+                    isValid(iter.value) && include.unshift(this.parseCustomElementExpr(iter.value))
+                    break
+                  default:
+                    nonexhaustive(iter.value)
+                }
+              } catch (e) {
+                logWarnError(e)
               }
+              iter = iter.prev
             }
             if (include.length > 0) {
               acc.push({ include })
@@ -534,8 +631,8 @@ export class LikeC4ModelParser {
             return acc
           }
           if (ast.isViewRuleStyle(n)) {
-            const styleProps = toElementStyle(n.styleprops)
-            const targets = n.targets.map(n => this.parseElementExpr(n))
+            const styleProps = toElementStyle(n.props)
+            const targets = this.parseElementExpressionsIterator(n.target)
             if (targets.length > 0) {
               acc.push({
                 targets,

package/src/model-change/changeElementStyle.ts

@@ -1,6 +1,6 @@
 import { type Fqn, invariant, isAncestor, type NonEmptyArray, nonNullable, type ViewChanges } from '@likec4/core'
 import { GrammarUtils } from 'langium'
-import { entries, filter, findLast, last } from 'remeda'
+import { entries, filter, findLast, isTruthy, last } from 'remeda'
 import { type Range, TextEdit } from 'vscode-languageserver-protocol'
 import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
 import type { FqnIndex } from '../model'
@@ -12,7 +12,7 @@ const asViewStyleRule = (target: string, style: ViewChanges.ChangeElementStyle['
   const indentStr = indent > 0 ? ' '.repeat(indent) : ''
   return [
     indentStr + `style ${target} {`,
-    ...entries.strict(style).map(([key, value]) =>
+    ...entries(style).map(([key, value]) =>
       indentStr + `  ${key} ${key === 'opacity' ? value.toString() + '%' : value}`
     ),
     indentStr + `}`
@@ -37,8 +37,8 @@ const isMatchingViewRule =
     if (!ast.isViewRuleStyle(rule)) {
       return false
     }
-    const [target, ...rest] = rule.targets
-    if (!target || rest.length > 0 || !ast.isElementRef(target)) {
+    const target = rule.target.value
+    if (!target || isTruthy(rule.target.prev) || !ast.isElementRef(target)) {
       return false
     }
     const ref = target.el.ref
@@ -125,9 +125,9 @@ export function changeElementStyle(services: LikeC4Services, {
     for (const { rule } of existing) {
       const ruleCstNode = rule.$cstNode
       invariant(ruleCstNode, 'RuleCstNode not found')
-      for (const [key, _value] of entries.strict(style)) {
+      for (const [key, _value] of entries(style)) {
         const value = key === 'opacity' ? _value.toString() + '%' : _value
-        const ruleProp = rule.styleprops.find(p => p.key === key)
+        const ruleProp = rule.props.find(p => p.key === key)
         // replace existing  property
         if (ruleProp && ruleProp.$cstNode) {
           const { range: { start, end } } = nonNullable(