@likec4/language-server 1.13.0 → 1.15.0

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

@@ -4,7 +4,9 @@ import { isNullish } from 'remeda'
 
 type Predicate<T> = (x: T) => boolean
 
-export function elementExprToPredicate(target: Expr.ElementPredicateExpression): Predicate<Element> {
+export function elementExprToPredicate<T extends Pick<Element, 'id' | 'kind' | 'tags'>>(
+  target: Expr.ElementPredicateExpression
+): Predicate<T> {
   if (Expr.isElementWhere(target)) {
     const predicate = elementExprToPredicate(target.where.expr)
     const where = whereOperatorAsPredicate(target.where.condition)

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

@@ -8,7 +8,7 @@ import {
   invariant,
   nonNullable
 } from '@likec4/core'
-import { difference, filter, map, pipe, sort } from 'remeda'
+import { difference, filter, map, pipe, sort, tap } from 'remeda'
 import { Graph, postorder } from '../../utils/graphlib'
 
 // side effect
@@ -27,9 +27,16 @@ export function sortNodes({
   nodes: ComputedNode[]
   edges: ComputedEdge[]
 }): ComputedNode[] {
-  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,
@@ -55,9 +62,6 @@ export function sortNodes({
   for (const n of nodes) {
     g.setNode(n.id, n.id)
     if (n.children.length > 0) {
-      // n.children.forEach(c => {
-      //   g.setEdge(n.id, c, undefined, `${n.id}:${c}`)
-      // })
       n.inEdges.forEach(e => {
         const edge = getEdge(e)
         // if this edge from leaf to the child of this node
@@ -83,15 +87,15 @@ export 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() as Fqn[]
   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)
   }
 

package/src/references/scope-computation.ts

@@ -20,7 +20,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   ): Promise<AstNodeDescription[]> {
     const docExports: AstNodeDescription[] = []
     try {
-      const { specifications, models, views, likec4lib } = document.parseResult.value
+      const { specifications, models, views, globals, likec4lib } = document.parseResult.value
 
       // Process library
       this.exportLibrary(likec4lib, docExports, document)
@@ -33,6 +33,9 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
 
       // Process views
       this.exportViews(views, docExports, document)
+
+      // Process global
+      this.exportGlobals(globals, docExports, document)
     } catch (e) {
       logError(e)
     }
@@ -58,6 +61,26 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     }
   }
 
+  private exportGlobals(
+    globals: ast.Globals[] | undefined,
+    docExports: AstNodeDescription[],
+    document: LikeC4LangiumDocument
+  ) {
+    if (isNullish(globals) || globals.length === 0) {
+      return
+    }
+    for (const globalStyleAst of globals.flatMap(g => g.styles)) {
+      try {
+        const id = globalStyleAst.id
+        if (isTruthy(id.name)) {
+          docExports.push(this.descriptions.createDescription(id, id.name, document))
+        }
+      } catch (e) {
+        logError(e)
+      }
+    }
+  }
+
   private exportModel(
     models: ast.Model[] | undefined,
     docExports: AstNodeDescription[],

package/src/validation/index.ts

@@ -8,6 +8,8 @@ import { iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChe
 import { relationBodyChecks, relationChecks } from './relation'
 import {
   elementKindChecks,
+  globalsChecks,
+  globalStyleIdChecks,
   modelRuleChecks,
   relationshipChecks,
   specificationRuleChecks,
@@ -31,6 +33,8 @@ export function registerValidationChecks(services: LikeC4Services) {
     IconProperty: iconPropertyRuleChecks(services),
     SpecificationRule: specificationRuleChecks(services),
     Model: modelRuleChecks(services),
+    Globals: globalsChecks(services),
+    GlobalStyleId: globalStyleIdChecks(services),
     DynamicViewStep: dynamicViewStep(services),
     LikeC4View: viewChecks(services),
     Element: elementChecks(services),

package/src/validation/specification.ts

@@ -27,6 +27,17 @@ export const modelRuleChecks = (_: LikeC4Services): ValidationCheck<ast.Model> =
   }
 }
 
+export const globalsChecks = (_: LikeC4Services): ValidationCheck<ast.Globals> => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept('warning', `Prefer one global 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) => {
@@ -118,3 +129,22 @@ export const relationshipChecks = (
     }
   }
 }
+
+export const globalStyleIdChecks = (
+  services: LikeC4Services
+): ValidationCheck<ast.GlobalStyleId> => {
+  const index = services.shared.workspace.IndexManager
+  return (node, accept) => {
+    const sameName = index
+      .allElements(ast.GlobalStyleId)
+      .filter(s => s.name === node.name)
+      .limit(2)
+      .count()
+    if (sameName > 1) {
+      accept('error', `Duplicate GlobalStyleId name '${node.name}'`, {
+        node: node,
+        property: 'name'
+      })
+    }
+  }
+}

package/src/view-utils/index.ts

@@ -1,3 +1,4 @@
 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

@@ -0,0 +1,72 @@
+import {
+  type DynamicView,
+  type ElementView,
+  type GlobalStyle,
+  type GlobalStyleID,
+  isDynamicView,
+  isElementView,
+  isViewRuleGlobalStyle,
+  type LikeC4View,
+  nonexhaustive
+} from '@likec4/core'
+import { logger } from '@likec4/log'
+
+export function resolveGlobalRules(
+  view: LikeC4View,
+  globalStyles: Record<GlobalStyleID, GlobalStyle>
+): LikeC4View {
+  if (isElementView(view)) {
+    return resolveGlobalStyleInElementView(view, globalStyles)
+  } else if (isDynamicView(view)) {
+    return resolveGlobalStyleInDynamicView(view, globalStyles)
+  }
+  nonexhaustive(view)
+}
+
+function resolveGlobalStyleInElementView(
+  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
+      }
+    })
+
+  return {
+    ...view,
+    rules: resolvedRules
+  }
+}
+
+function resolveGlobalStyleInDynamicView(
+  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
+      }
+    })
+
+  return {
+    ...view,
+    rules: resolvedRules
+  }
+}