@likec4/language-server 1.12.1 → 1.13.0

package/src/like-c4.langium

@@ -194,8 +194,10 @@ MetadataAttribute:
 // Views -------------------------------------
 
 ModelViews:
-  name='views' '{'
-    views+=LikeC4ViewRule*
+  name='views' '{' (
+      views+=LikeC4ViewRule |
+      styles+=ViewRuleStyle
+    )*
   '}';
 
 type LikeC4View = ElementView | DynamicView;

package/src/lsp/CompletionProvider.ts

@@ -23,10 +23,10 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
     if (['views', 'specification', 'model'].includes(keyword.value)) {
       return acceptor(context, {
         label: keyword.value,
-        detail: `Insert ${keyword} block`,
+        detail: `Insert ${keyword.value} block`,
         kind: CompletionItemKind.Module,
         insertTextFormat: InsertTextFormat.Snippet,
-        insertText: `${keyword} {\n\t$0\n}`
+        insertText: `${keyword.value} {\n\t$0\n}`
       })
     }
     if (keyword.value === 'dynamic') {

package/src/model/model-parser.ts

@@ -36,6 +36,9 @@ import { stringHash } from '../utils'
 import { deserializeFromComment, hasManualLayout } from '../view-utils/manual-layout'
 import type { FqnIndex } from './fqn-index'
 import { parseWhereClause } from './model-parser-where'
+import {
+  type NotationProperty
+} from '../generated/ast'
 
 const { getDocument } = AstUtils
 
@@ -283,17 +286,23 @@ export class LikeC4ModelParser {
   }
 
   private parseViews(doc: ParsedLikeC4LangiumDocument, isValid: IsValidFn) {
-    const views = doc.parseResult.value.views.flatMap(v => isValid(v) ? v.views : [])
-    for (const view of views) {
-      try {
-        if (!isValid(view)) {
-          continue
+    const viewBlocks = doc.parseResult.value.views.filter(v => isValid(v))
+    for (const viewBlock of viewBlocks) {
+      const localStyles = viewBlock.styles
+        .flatMap(s => this.parseViewRuleStyle(s, isValid))
+      const stylesToApply = localStyles
+
+      for (const view of viewBlock.views) {
+        try {
+          if (!isValid(view)) {
+            continue
+          }
+          doc.c4Views.push(
+            ast.isElementView(view) ? this.parseElementView(view, stylesToApply, isValid) : this.parseDynamicElementView(view, stylesToApply, isValid)
+          )
+        } catch (e) {
+          logWarnError(e)
         }
-        doc.c4Views.push(
-          ast.isElementView(view) ? this.parseElementView(view, isValid) : this.parseDynamicElementView(view, isValid)
-        )
-      } catch (e) {
-        logWarnError(e)
       }
     }
   }
@@ -596,16 +605,7 @@ export class LikeC4ModelParser {
       return this.parseViewRulePredicate(astRule, isValid)
     }
     if (ast.isViewRuleStyle(astRule)) {
-      const styleProps = toElementStyle(astRule.props.filter(ast.isStyleProperty), isValid)
-      const notation = removeIndent(astRule.props.find(ast.isNotationProperty)?.value)
-      const targets = this.parseElementExpressionsIterator(astRule.target)
-      return {
-        targets,
-        ...(notation && { notation }),
-        style: {
-          ...styleProps
-        }
-      }
+      return this.parseViewRuleStyle(astRule, isValid)
     }
     if (ast.isViewRuleAutoLayout(astRule)) {
       return toAutoLayout(astRule)
@@ -613,6 +613,26 @@ export class LikeC4ModelParser {
     nonexhaustive(astRule)
   }
 
+  private parseViewRuleStyle(astRule: ast.ViewRuleStyle, isValid: IsValidFn): c4.ViewRuleStyle {
+    const styleProps = astRule.props.filter(ast.isStyleProperty)
+    const targets = astRule.target
+    const notation = astRule.props.find(ast.isNotationProperty)
+    return this.parseRuleStyle(styleProps, targets, isValid, notation)
+  }
+
+  private parseRuleStyle(styleProperties: ast.StyleProperty[], elementExpressionsIterator: ast.ElementExpressionsIterator, isValid: IsValidFn, notationProperty?: NotationProperty): c4.ViewRuleStyle {
+    const styleProps = toElementStyle(styleProperties, isValid)
+    const notation = removeIndent(notationProperty?.value)
+    const targets = this.parseElementExpressionsIterator(elementExpressionsIterator)
+    return {
+      targets,
+      ...(notation && { notation }),
+      style: {
+        ...styleProps
+      }
+    }
+  }
+
   private parseViewManualLaout(node: ast.DynamicView | ast.ElementView): c4.ViewManualLayout | undefined {
     const commentNode = CstUtils.findCommentNode(node.$cstNode, ['BLOCK_COMMENT'])
     if (!commentNode || !hasManualLayout(commentNode.text)) {
@@ -709,7 +729,7 @@ export class LikeC4ModelParser {
     return step
   }
 
-  private parseElementView(astNode: ast.ElementView, isValid: IsValidFn): ParsedAstElementView {
+  private parseElementView(astNode: ast.ElementView, additionalStyles: c4.ViewRuleStyle[], isValid: IsValidFn): ParsedAstElementView {
     const body = astNode.body
     invariant(body, 'ElementView body is not defined')
     const astPath = this.getAstNodePath(astNode)
@@ -750,14 +770,14 @@ export class LikeC4ModelParser {
       description,
       tags,
       links: isNonEmptyArray(links) ? links : null,
-      rules: body.rules.flatMap(n => {
+      rules: [...additionalStyles, ...body.rules.flatMap(n => {
         try {
           return isValid(n) ? this.parseViewRule(n, isValid) : []
         } catch (e) {
           logWarnError(e)
           return []
         }
-      }),
+      })],
       ...(viewOf && { viewOf }),
       ...(manualLayout && { manualLayout })
     }
@@ -774,7 +794,7 @@ export class LikeC4ModelParser {
     return view
   }
 
-  private parseDynamicElementView(astNode: ast.DynamicView, isValid: IsValidFn): ParsedAstDynamicView {
+  private parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: c4.ViewRuleStyle[], isValid: IsValidFn): ParsedAstDynamicView {
     const body = astNode.body
     invariant(body, 'DynamicElementView body is not defined')
     // only valid props
@@ -807,55 +827,14 @@ export class LikeC4ModelParser {
       description,
       tags,
       links: isNonEmptyArray(links) ? links : null,
-      rules: body.rules.reduce((acc, n) => {
-        if (!isValid(n)) {
-          return acc
-        }
+      rules: [...additionalStyles, ...body.rules.flatMap(n => {
         try {
-          if (ast.isDynamicViewIncludePredicate(n)) {
-            const include = [] as c4.ElementPredicateExpression[]
-            let iter: ast.DynamicViewPredicateIterator | undefined = n.predicates
-            while (iter) {
-              try {
-                if (isValid(iter.value as any)) {
-                  const c4expr = this.parseElementPredicate(iter.value, isValid)
-                  include.unshift(c4expr)
-                }
-              } catch (e) {
-                logWarnError(e)
-              }
-              iter = iter.prev
-            }
-            if (include.length > 0) {
-              acc.push({ include })
-            }
-            return acc
-          }
-          if (ast.isViewRuleStyle(n)) {
-            const styleProps = toElementStyle(n.props.filter(ast.isStyleProperty), isValid)
-            const notation = removeIndent(n.props.find(ast.isNotationProperty)?.value)
-            const targets = this.parseElementExpressionsIterator(n.target)
-            if (targets.length > 0) {
-              acc.push({
-                targets,
-                ...(notation && { notation }),
-                style: {
-                  ...styleProps
-                }
-              })
-            }
-            return acc
-          }
-          if (ast.isViewRuleAutoLayout(n)) {
-            acc.push(toAutoLayout(n))
-            return acc
-          }
-          nonexhaustive(n)
+          return isValid(n) ? this.parseDynamicViewRule(n, isValid) : []
         } catch (e) {
           logWarnError(e)
-          return acc
+          return []
         }
-      }, [] as Array<c4.DynamicViewRule>),
+      }, [] as Array<c4.DynamicViewRule>)],
       steps: body.steps.reduce((acc, n) => {
         try {
           if (isValid(n)) {
@@ -874,6 +853,36 @@ export class LikeC4ModelParser {
     }
   }
 
+  private parseDynamicViewRule(astRule: ast.DynamicViewRule, isValid: IsValidFn): c4.DynamicViewRule {
+    if (ast.isDynamicViewIncludePredicate(astRule)) {
+      return this.parseDynamicViewIncludePredicate(astRule, isValid)
+    }
+    if (ast.isViewRuleStyle(astRule)) {
+      return this.parseViewRuleStyle(astRule, isValid)
+    }
+    if (ast.isViewRuleAutoLayout(astRule)) {
+      return toAutoLayout(astRule)
+    }
+    nonexhaustive(astRule)
+  }
+
+  private parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate, isValid: IsValidFn): c4.DynamicViewIncludeRule {
+    const include = [] as c4.ElementPredicateExpression[]
+    let iter: ast.DynamicViewPredicateIterator | undefined = astRule.predicates
+    while (iter) {
+      try {
+        if (isValid(iter.value as any)) {
+          const c4expr = this.parseElementPredicate(iter.value, isValid)
+          include.unshift(c4expr)
+        }
+      } catch (e) {
+        logWarnError(e)
+      }
+      iter = iter.prev
+    }
+    return { include }
+  }
+
   protected resolveFqn(node: ast.Element | ast.ExtendElement) {
     if (ast.isExtendElement(node)) {
       return getFqnElementRef(node.element)

package/src/model-change/ModelChanges.ts

@@ -9,34 +9,6 @@ import { changeElementStyle } from './changeElementStyle'
 import { changeViewLayout } from './changeViewLayout'
 import { saveManualLayout } from './saveManualLayout'
 
-// function unionRangeOfAllEdits(ranges: Range[]): Range {
-//   let startLine = Number.MAX_SAFE_INTEGER
-//   let endLine = Number.MIN_SAFE_INTEGER
-
-//   let startCharacter = Number.MAX_SAFE_INTEGER
-//   let endCharacter = Number.MIN_SAFE_INTEGER
-
-//   for (const { start, end } of ranges) {
-//     if (start.line <= startLine) {
-//       if (startLine == start.line) {
-//         startCharacter = Math.min(start.character, startCharacter)
-//       } else {
-//         startLine = start.line
-//         startCharacter = start.character
-//       }
-//     }
-//     if (endLine <= end.line) {
-//       if (endLine == end.line) {
-//         endCharacter = Math.max(end.character, endCharacter)
-//       } else {
-//         endLine = end.line
-//         endCharacter = end.character
-//       }
-//     }
-//   }
-//   return Range.create(startLine, startCharacter, endLine, endCharacter)
-// }
-
 export class LikeC4ModelChanges {
   private locator: LikeC4ModelLocator
 

package/src/model-change/changeViewLayout.ts

@@ -1,6 +1,6 @@
-import { invariant, type ViewRuleAutoLayout } from '@likec4/core'
+import { invariant, type ViewChange } from '@likec4/core'
 import { GrammarUtils } from 'langium'
-import { isDefined } from 'remeda'
+import { isNumber } from 'remeda'
 import { TextEdit } from 'vscode-languageserver-types'
 import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument, toAstViewLayoutDirection } from '../ast'
 import type { LikeC4Services } from '../module'
@@ -11,7 +11,7 @@ type ChangeViewLayoutArg = {
   view: ParsedAstView
   doc: ParsedLikeC4LangiumDocument
   viewAst: ast.LikeC4View
-  layout: ViewRuleAutoLayout
+  layout: ViewChange.ChangeAutoLayout['layout']
 }
 
 export function changeViewLayout(_services: LikeC4Services, {
@@ -28,9 +28,9 @@ export function changeViewLayout(_services: LikeC4Services, {
 
   let newRule = `autoLayout ${newdirection}`
 
-  if (isDefined(layout.rankSep)) {
+  if (isNumber(layout.rankSep)) {
     newRule += ` ${layout.rankSep}`
-    if (isDefined(layout.nodeSep)) {
+    if (isNumber(layout.nodeSep)) {
       newRule += ` ${layout.nodeSep}`
     }
   }

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

@@ -178,7 +178,7 @@ export class ComputeCtx {
       autoLayout: {
         direction: autoLayoutRule?.direction ?? 'TB',
         ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
-        ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }),
+        ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep })
       },
       nodes: map(nodes, omit(['notation'])),
       edges: applyCustomRelationProperties(rules, nodes, sortedEdges),

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

@@ -203,7 +203,7 @@ export class DynamicViewComputeCtx {
       autoLayout: {
         direction: autoLayoutRule?.direction ?? 'LR',
         ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
-        ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }),
+        ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep })
       },
       nodes: map(nodes, omit(['notation'])),
       edges,

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

@@ -8,7 +8,7 @@ import {
   invariant,
   nonNullable
 } from '@likec4/core'
-import { difference, filter, map, pipe, sort, take } from 'remeda'
+import { difference, filter, map, pipe, sort } from 'remeda'
 import { Graph, postorder } from '../../utils/graphlib'
 
 // side effect
@@ -53,7 +53,7 @@ export function sortNodes({
   }
 
   for (const n of nodes) {
-    g.setNode(n.id)
+    g.setNode(n.id, n.id)
     if (n.children.length > 0) {
       // n.children.forEach(c => {
       //   g.setEdge(n.id, c, undefined, `${n.id}:${c}`)
@@ -79,7 +79,7 @@ export function sortNodes({
     }
   }
 
-  let sources = g.sources()
+  let sources = g.sources() as unknown as Fqn[]
   if (sources.length === 0) {
     sources = pipe(
       nodes,

package/src/test/testServices.ts

@@ -75,14 +75,15 @@ export function createTestServices(workspace = 'file:///test/workspace') {
       await documentBuilder.build([document], { validation: true })
     })
 
-    const edits = await services.lsp.Formatter?.formatDocument(
-      document, 
+    const edits = await formatter?.formatDocument(
+      document,
       {
-        options: {tabSize: 2, insertSpaces: true},
+        options: { tabSize: 2, insertSpaces: true },
         textDocument: { uri: document.uri.toString() }
-      });
+      }
+    )
 
-    return TextDocument.applyEdits(document.textDocument, edits ?? []);
+    return TextDocument.applyEdits(document.textDocument, edits ?? [])
   }
 
   type ValidateAllResult = {
@@ -116,6 +117,9 @@ export function createTestServices(workspace = 'file:///test/workspace') {
     return model
   }
 
+  /**
+   * This will clear all documents
+   */
   const resetState = async () => {
     await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
       const docs = langiumDocuments.all.toArray().map(doc => doc.uri)

package/src/utils/graphlib.ts

@@ -1,11 +1,9 @@
-// '@dagrejs/graphlib' is a CommonJS module
-// Here is a workaround to import it
+import dagre from '@dagrejs/dagre'
 
-import { Graph } from '@dagrejs/graphlib'
-import graphlib from '@dagrejs/graphlib'
+const Graph = dagre.graphlib.Graph
 
 export { Graph }
 
-export const postorder = graphlib.alg.postorder
-export const findCycles = graphlib.alg.findCycles
-export const isAcyclic = graphlib.alg.isAcyclic
+export const postorder = dagre.graphlib.alg.postorder
+export const findCycles = dagre.graphlib.alg.findCycles
+export const isAcyclic = dagre.graphlib.alg.isAcyclic

package/src/validation/_shared.ts

@@ -7,7 +7,8 @@ export const RESERVED_WORDS = [
   'it',
   'self',
   'super',
-  'likec4lib'
+  'likec4lib',
+  'global'
 ]
 
 export function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T> {

package/src/validation/index.ts

@@ -9,7 +9,6 @@ import { relationBodyChecks, relationChecks } from './relation'
 import {
   elementKindChecks,
   modelRuleChecks,
-  modelViewsChecks,
   relationshipChecks,
   specificationRuleChecks,
   tagChecks
@@ -32,7 +31,6 @@ export function registerValidationChecks(services: LikeC4Services) {
     IconProperty: iconPropertyRuleChecks(services),
     SpecificationRule: specificationRuleChecks(services),
     Model: modelRuleChecks(services),
-    ModelViews: modelViewsChecks(services),
     DynamicViewStep: dynamicViewStep(services),
     LikeC4View: viewChecks(services),
     Element: elementChecks(services),

package/src/validation/specification.ts

@@ -27,17 +27,6 @@ export const modelRuleChecks = (_: LikeC4Services): ValidationCheck<ast.Model> =
   }
 }
 
-export const modelViewsChecks = (_: LikeC4Services): ValidationCheck<ast.ModelViews> => {
-  return (node, accept) => {
-    if (node.$containerIndex && node.$containerIndex > 0) {
-      accept('warning', `Prefer one views block per document`, {
-        node: node,
-        property: 'name'
-      })
-    }
-  }
-}
-
 export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast.ElementKind> => {
   const index = services.shared.workspace.IndexManager
   return tryOrLog((node, accept) => {

package/src/view-utils/resolve-extended-views.ts

@@ -17,7 +17,7 @@ export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
     compound: false
   })
   for (const view of values(unresolvedViews)) {
-    g.setNode(view.id)
+    g.setNode(view.id, view.id)
     if (isExtendsElementView(view)) {
       // view -> parent
       g.setEdge(view.id, view.extends)
@@ -40,7 +40,7 @@ export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
     g.removeNode(cycledNode)
   }
 
-  const ordered = postorder(g, g.sources())
+  const ordered = postorder(g, g.sources() as unknown as string[])
 
   return ordered.reduce((acc, id) => {
     const view = unresolvedViews[id]