@likec4/language-server 1.9.0 → 1.10.1

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

@@ -13,7 +13,7 @@ import type {
   RelationshipKind,
   RelationshipLineType,
   Tag,
-  ThemeColor,
+  ViewID,
   ViewRulePredicate
 } from '@likec4/core'
 import {
@@ -30,7 +30,7 @@ import {
   parentFqn,
   whereOperatorAsPredicate
 } from '@likec4/core'
-import { first, flatMap, hasAtLeast, isTruthy, map, omit, unique } from 'remeda'
+import { filter, hasAtLeast, isNonNull, isTruthy, map, omit, only, pipe, reduce, sort, unique } from 'remeda'
 import { calcViewLayoutHash } from '../../view-utils/view-hash'
 import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
@@ -39,6 +39,7 @@ import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
 import { buildComputeNodes } from '../utils/buildComputeNodes'
 import { buildElementNotations } from '../utils/buildElementNotations'
 import { sortNodes } from '../utils/sortNodes'
+import { uniqueTags } from '../utils/uniqueTags'
 import {
   type ElementPredicateFn,
   excludeElementKindOrTag,
@@ -192,7 +193,7 @@ export class ComputeCtx {
   protected computeEdges(): ComputedEdge[] {
     return this.ctxEdges.map((e): ComputedEdge => {
       invariant(hasAtLeast(e.relations, 1), 'Edge must have at least one relation')
-      const relations = e.relations.toSorted(compareRelations)
+      const relations = sort(e.relations, compareRelations)
       const source = e.source.id
       const target = e.target.id
 
@@ -205,70 +206,85 @@ export class ComputeCtx {
         relations: relations.map(r => r.id)
       }
 
-      let relation:
-        | Pick<Relation, 'title' | 'kind' | 'description' | 'technology' | 'color' | 'line' | 'head' | 'tail' | 'tags'>
-        | {
-          // TODO refactor with type-fest
-          title: string
-          description?: string | undefined
-          technology?: string | undefined
-          kind?: RelationshipKind | undefined
-          color?: Color | undefined
-          line?: RelationshipLineType | undefined
-          head?: RelationshipArrowType | undefined
-          tail?: RelationshipArrowType | undefined
-          tags?: NonEmptyArray<Tag>
-        }
-        | undefined
-      if (relations.length === 1) {
-        relation = relations[0]
-      } else {
-        relation = relations.find(r => r.source === source && r.target === target)
-        // relation ??= relations.toReversed().find(r => r.source === source || r.target === target)
-      }
+      let relation: {
+        // TODO refactor with type-fest
+        title: string
+        description?: string | undefined
+        technology?: string | undefined
+        kind?: RelationshipKind | undefined
+        color?: Color | undefined
+        line?: RelationshipLineType | undefined
+        head?: RelationshipArrowType | undefined
+        tail?: RelationshipArrowType | undefined
+        tags?: NonEmptyArray<Tag>
+        navigateTo?: ViewID | undefined
+      } | undefined
+      relation = only(relations) ?? pipe(
+        relations,
+        filter(r => r.source === source && r.target === target),
+        only()
+      )
 
       // This edge represents mutliple relations
       // We use label if only it is the same for all relations
       if (!relation) {
-        relation = relations.reduce((acc, r) => {
-          if (r.color && acc.color !== r.color) {
-            acc.color = undefined
-          }
-          if (r.kind && acc.kind !== r.kind) {
-            acc.kind = undefined
-          }
-          if (r.head && acc.head !== r.head) {
-            acc.head = undefined
-          }
-          if (r.tail && acc.tail !== r.tail) {
-            acc.tail = undefined
-          }
-          if (r.line && acc.line !== r.line) {
-            acc.line = undefined
-          }
-          if (r.description && acc.description !== r.description) {
-            acc.description = undefined
-          }
-          if (r.technology && acc.technology !== r.technology) {
-            acc.technology = undefined
-          }
-          if (isTruthy(r.title) && acc.title !== r.title) {
-            acc.title = '[...]'
-          }
-          return acc
-        }, {
-          title: first(flatMap(relations, r => isTruthy(r.title) ? r.title : [])) ?? '[...]',
-          description: first(flatMap(relations, r => isTruthy(r.description) ? r.description : [])),
-          technology: first(flatMap(relations, r => isTruthy(r.technology) ? r.technology : [])),
-          kind: first(flatMap(relations, r => isTruthy(r.kind) ? r.kind : [])),
-          head: first(flatMap(relations, r => isTruthy(r.head) ? r.head : [])),
-          tail: first(flatMap(relations, r => isTruthy(r.tail) ? r.tail : [])),
-          color: first(flatMap(relations, r => isTruthy(r.color) ? r.color : [])),
-          line: first(flatMap(relations, r => isTruthy(r.line) ? r.line : []))
-        })
+        const allprops = pipe(
+          relations,
+          reduce((acc, r) => {
+            if (isTruthy(r.title) && !acc.title.includes(r.title)) {
+              acc.title.push(r.title)
+            }
+            if (isTruthy(r.description) && !acc.description.includes(r.description)) {
+              acc.description.push(r.description)
+            }
+            if (isTruthy(r.technology) && !acc.technology.includes(r.technology)) {
+              acc.technology.push(r.technology)
+            }
+            if (isTruthy(r.kind) && !acc.kind.includes(r.kind)) {
+              acc.kind.push(r.kind)
+            }
+            if (isTruthy(r.color) && !acc.color.includes(r.color)) {
+              acc.color.push(r.color)
+            }
+            if (isTruthy(r.line) && !acc.line.includes(r.line)) {
+              acc.line.push(r.line)
+            }
+            if (isTruthy(r.head) && !acc.head.includes(r.head)) {
+              acc.head.push(r.head)
+            }
+            if (isTruthy(r.tail) && !acc.tail.includes(r.tail)) {
+              acc.tail.push(r.tail)
+            }
+            if (isTruthy(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
+              acc.navigateTo.push(r.navigateTo)
+            }
+            return acc
+          }, {
+            title: [] as string[],
+            description: [] as string[],
+            technology: [] as string[],
+            kind: [] as RelationshipKind[],
+            head: [] as RelationshipArrowType[],
+            tail: [] as RelationshipArrowType[],
+            color: [] as Color[],
+            line: [] as RelationshipLineType[],
+            navigateTo: [] as ViewID[]
+          })
+        )
+        relation = {
+          title: only(allprops.title) ?? '[...]',
+          description: only(allprops.description),
+          technology: only(allprops.technology),
+          kind: only(allprops.kind),
+          head: only(allprops.head),
+          tail: only(allprops.tail),
+          color: only(allprops.color),
+          line: only(allprops.line),
+          navigateTo: only(allprops.navigateTo)
+        }
       }
 
-      const tags = unique(flatMap(relations, r => r.tags ?? []))
+      const tags = uniqueTags(relations)
 
       return Object.assign(
         edge,
@@ -280,7 +296,8 @@ export class ComputeCtx {
         relation.line && { line: relation.line },
         relation.head && { head: relation.head },
         relation.tail && { tail: relation.tail },
-        hasAtLeast(tags, 1) && { tags }
+        relation.navigateTo && { navigateTo: relation.navigateTo },
+        tags && { tags }
       )
     })
   }
@@ -349,29 +366,40 @@ export class ComputeCtx {
     }
   }
 
-  protected excludeImplicit(...excludes: Element[]) {
-    for (const el of excludes) {
-      this.implicits.delete(el)
-    }
-  }
+  // protected excludeImplicit(...excludes: Element[]) {
+  //   for (const el of excludes) {
+  //     this.implicits.delete(el)
+  //   }
+  // }
 
   protected excludeRelation(...relations: Relation[]) {
+    if (relations.length === 0) {
+      return
+    }
     const excludedImplicits = new Set<Element>()
-    for (const relation of relations) {
-      let edge
-      while ((edge = this.ctxEdges.find(e => e.relations.includes(relation)))) {
-        if (edge.relations.length === 1) {
+    const ctxEdges = pipe(
+      this.ctxEdges,
+      map(edge => {
+        const edgerelations = edge.relations.filter(r => !relations.includes(r))
+        if (edgerelations.length === 0) {
           excludedImplicits.add(edge.source)
           excludedImplicits.add(edge.target)
-          this.ctxEdges.splice(this.ctxEdges.indexOf(edge), 1)
-          continue
+          return null
         }
-        edge.relations = edge.relations.filter(r => r !== relation)
-      }
-    }
+        if (edgerelations.length !== edge.relations.length) {
+          return {
+            ...edge,
+            relations: edgerelations
+          }
+        }
+        return edge
+      }),
+      filter(isNonNull)
+    )
     if (excludedImplicits.size === 0) {
       return
     }
+    this.ctxEdges = ctxEdges
     const remaining = this.includedElements
     if (remaining.size === 0) {
       this.implicits.clear()
@@ -541,9 +569,12 @@ export class ComputeCtx {
   }
 
   protected getEdgeLabel(
-    relation: { title: String | undefined; technology?: String | undefined }
-  ): { label: String } | false {
-    const labelParts: String[] = []
+    relation: {
+      title: string
+      technology?: string | undefined
+    }
+  ) {
+    const labelParts: string[] = []
 
     if (isTruthy(relation.title)) {
       labelParts.push(relation.title)
@@ -553,6 +584,6 @@ export class ComputeCtx {
       labelParts.push(`[${relation.technology}]`)
     }
 
-    return labelParts.length > 0 && { label: labelParts.join('\n') }
+    return labelParts.length > 0 ? { label: labelParts.join('\n') } : {}
   }
 }

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

@@ -1,6 +1,6 @@
 import type { Element, Relation } from '@likec4/core'
 import { Expr, isAncestor, nonexhaustive, parentFqn } from '@likec4/core'
-import { allPass, filter as remedaFilter, flatMap, isNullish as isNil, map, pipe } from 'remeda'
+import { allPass, filter as remedaFilter, flatMap, isNullish as isNil, map, pipe, unique } from 'remeda'
 import { elementExprToPredicate } from '../utils/elementExpressionToPredicate'
 import type { ComputeCtx } from './compute'
 
@@ -318,13 +318,11 @@ const filterEdges = (edges: ReadonlyArray<ComputeCtx.Edge>, where?: RelationPred
 }
 
 const filterRelations = (edges: ComputeCtx.Edge[], where?: RelationPredicateFn) => {
-  if (!where) {
-    return edges.flatMap(e => e.relations)
-  }
   return pipe(
     edges,
     flatMap(e => e.relations),
-    remedaFilter(where)
+    where ? remedaFilter(where) : Identity,
+    unique()
   )
 }
 

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

@@ -3,13 +3,14 @@ import type {
   ComputedDynamicView,
   ComputedEdge,
   DynamicView,
+  DynamicViewStep,
   Element,
   NonEmptyArray,
   RelationID,
   RelationshipArrowType,
   RelationshipLineType,
   Tag,
-  ThemeColor
+  ViewID
 } from '@likec4/core'
 import {
   ancestorsFqn,
@@ -18,12 +19,13 @@ import {
   DefaultLineStyle,
   DefaultRelationshipColor,
   isDynamicViewIncludeRule,
+  isDynamicViewParallelSteps,
   isViewRuleAutoLayout,
   nonNullable,
   parentFqn,
   StepEdgeId
 } from '@likec4/core'
-import { hasAtLeast, isTruthy, map, omit, unique } from 'remeda'
+import { filter, flatMap, hasAtLeast, isTruthy, map, omit, only, pipe, unique } from 'remeda'
 import { calcViewLayoutHash } from '../../view-utils/view-hash'
 import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
@@ -34,6 +36,7 @@ import { elementExprToPredicate } from '../utils/elementExpressionToPredicate'
 
 export namespace DynamicViewComputeCtx {
   export interface Step {
+    id: StepEdgeId
     source: Element
     target: Element
     title: string | null
@@ -45,6 +48,7 @@ export namespace DynamicViewComputeCtx {
     tail?: RelationshipArrowType
     relations: RelationID[]
     isBackward: boolean
+    navigateTo?: ViewID
     tags?: NonEmptyArray<Tag>
   }
 }
@@ -63,6 +67,47 @@ export class DynamicViewComputeCtx {
     protected graph: LikeC4ModelGraph
   ) {}
 
+  private addStep(
+    {
+      source: stepSource,
+      target: stepTarget,
+      title: stepTitle,
+      isBackward,
+      navigateTo: stepNavigateTo,
+      ...step
+    }: DynamicViewStep,
+    index: number,
+    parent?: number
+  ) {
+    const id = parent ? StepEdgeId(parent, index) : StepEdgeId(index)
+    const source = this.graph.element(stepSource)
+    const target = this.graph.element(stepTarget)
+
+    this.explicits.add(source)
+    this.explicits.add(target)
+
+    const {
+      title,
+      relations,
+      tags,
+      navigateTo: derivedNavigateTo
+    } = this.findRelations(source, target)
+
+    const navigateTo = isTruthy(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo
+
+    this.steps.push({
+      id,
+      ...step,
+      source,
+      target,
+      title: stepTitle ?? title,
+      relations: relations ?? [],
+      isBackward: isBackward ?? false,
+      ...(navigateTo ? { navigateTo } : {}),
+      ...(tags ? { tags } : {})
+    })
+  }
+
   protected compute(): ComputedDynamicView {
     const {
       docUri: _docUri, // exclude docUri
@@ -71,32 +116,21 @@ export class DynamicViewComputeCtx {
       ...view
     } = this.view
 
-    for (
-      let {
-        source: stepSource,
-        target: stepTarget,
-        title: stepTitle,
-        isBackward,
-        ...step
-      } of viewSteps
-    ) {
-      const source = this.graph.element(stepSource)
-      const target = this.graph.element(stepTarget)
-
-      this.explicits.add(source)
-      this.explicits.add(target)
-
-      const { title, relations, tags } = this.findRelations(source, target)
-
-      this.steps.push({
-        ...step,
-        source,
-        target,
-        title: isTruthy(stepTitle) ? stepTitle : title,
-        relations: relations ?? [],
-        isBackward: isBackward ?? false,
-        ...(tags ? { tags } : {})
-      })
+    let stepNum = 1
+    for (const step of viewSteps) {
+      if (isDynamicViewParallelSteps(step)) {
+        if (step.__parallel.length === 0) {
+          continue
+        }
+        if (step.__parallel.length === 1) {
+          this.addStep(step.__parallel[0]!, stepNum)
+        } else {
+          step.__parallel.forEach((s, i) => this.addStep(s, i + 1, stepNum))
+        }
+      } else {
+        this.addStep(step, stepNum)
+      }
+      stepNum++
     }
 
     for (const rule of rules) {
@@ -111,12 +145,10 @@ export class DynamicViewComputeCtx {
     const elements = [...this.explicits]
     const nodesMap = buildComputeNodes(elements)
 
-    const edges = this.steps.map(({ source, target, relations, title, isBackward, ...step }, index) => {
+    const edges = this.steps.map(({ source, target, relations, title, isBackward, ...step }) => {
       const sourceNode = nonNullable(nodesMap.get(source.id), `Source node ${source.id} not found`)
       const targetNode = nonNullable(nodesMap.get(target.id), `Target node ${target.id} not found`)
-      const stepNum = index + 1
       const edge: ComputedEdge = {
-        id: StepEdgeId(stepNum),
         parent: commonAncestor(source.id, target.id),
         source: source.id,
         target: target.id,
@@ -183,49 +215,53 @@ export class DynamicViewComputeCtx {
     title: string | null
     tags: NonEmptyArray<Tag> | null
     relations: NonEmptyArray<RelationID> | null
+    navigateTo: ViewID | null
   } {
     const relationships = unique(this.graph.edgesBetween(source, target).flatMap(e => e.relations))
-    const alltags = unique(relationships.flatMap(r => r.tags ?? []))
-    const tags = hasAtLeast(alltags, 1) ? alltags : null
-
-    const relations = hasAtLeast(relationships, 1) ? map(relationships, r => r.id) : null
     if (relationships.length === 0) {
       return {
         title: null,
-        tags,
-        relations
+        tags: null,
+        relations: null,
+        navigateTo: null
       }
     }
-    let relation
-    if (relationships.length === 1) {
-      relation = relationships[0]
-    } else {
-      relation = relationships.find(r => r.source === source.id && r.target === target.id)
-    }
+    const alltags = pipe(
+      relationships,
+      flatMap(r => r.tags),
+      filter(isTruthy),
+      unique()
+    )
+    const tags = hasAtLeast(alltags, 1) ? alltags : null
+    const relations = hasAtLeast(relationships, 1) ? map(relationships, r => r.id) : null
 
-    if (relation && isTruthy(relation.title)) {
-      return {
-        title: relation.title,
-        tags,
-        relations
-      }
-    }
+    // Most closest relation
+    const relation = only(relationships) || relationships.find(r => r.source === source.id && r.target === target.id)
 
     // This edge represents mutliple relations
     // We use label if only it is the same for all relations
-    const labels = unique(relationships.flatMap(r => (isTruthy(r.title) ? r.title : [])))
-    if (labels.length === 1) {
-      return {
-        title: labels[0]!,
-        tags,
-        relations
-      }
-    }
+    const title = isTruthy(relation?.title) ? relation.title : pipe(
+      relationships,
+      map(r => r.title),
+      filter(isTruthy),
+      unique(),
+      only()
+    )
+
+    const navigateTo = !!relation?.navigateTo && relation.navigateTo !== this.view.id ? relation.navigateTo : pipe(
+      relationships,
+      map(r => r.navigateTo),
+      filter(isTruthy),
+      filter(v => v !== this.view.id),
+      unique(),
+      only()
+    )
 
     return {
-      title: null,
+      title: title ?? null,
       tags,
-      relations
+      relations,
+      navigateTo: navigateTo ?? null
     }
   }
 }

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

@@ -52,8 +52,8 @@ export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[]
       }))
     ),
     sortBy(
-      prop('title'),
       prop('shape'),
+      prop('title'),
       [
         n => n.kinds.length,
         'desc'

package/src/model-graph/utils/uniqueTags.test.ts

@@ -0,0 +1,42 @@
+import { compareNatural } from '@likec4/core'
+import { describe, expect, it } from 'vitest'
+import { uniqueTags } from './uniqueTags'
+
+describe('uniqueTags function', () => {
+  it('returns unique tags from an array of elements', () => {
+    const input = [
+      { tags: ['tag1', 'tag2', 'tag3'] },
+      { tags: ['tag2', 'tag3', 'tag4'] },
+      { tags: ['tag3', 'tag4', 'tag5'] }
+    ] as const
+    const result = uniqueTags(input)
+    expect(result).toEqual(['tag1', 'tag2', 'tag3', 'tag4', 'tag5'])
+  })
+
+  it('should return unique tags naturally sorted', () => {
+    const input = [
+      { tags: ['tag1', 'tag20', 'tag30'] },
+      { tags: ['tag2', 'tag23', 'tag34'] },
+      { tags: ['tag3'] }
+    ] as const
+    const result = uniqueTags(input)
+    expect(result).toEqual([
+      'tag1',
+      'tag2',
+      'tag3',
+      'tag20',
+      'tag23',
+      'tag30',
+      'tag34'
+    ].sort(compareNatural))
+  })
+
+  it('returns null if the tags array is null', () => {
+    const input = [
+      { tags: null },
+      {}
+    ]
+    const result = uniqueTags(input)
+    expect(result).toBeNull()
+  })
+})

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

@@ -0,0 +1,19 @@
+import { compareNatural, hasAtLeast, type NonEmptyReadonlyArray, type Tag } from '@likec4/core'
+import { flatMap, pipe, sort, unique } from 'remeda'
+import type { LiteralUnion } from 'type-fest'
+
+/**
+ * Extracts unique tags from an array of elements.
+ * and sort in natural order; returns null if no tags are present.
+ */
+export function uniqueTags<T extends { tags?: NonEmptyReadonlyArray<LiteralUnion<Tag, string>> | null }>(
+  elements: ReadonlyArray<T>
+) {
+  const tags = pipe(
+    elements,
+    flatMap(e => e.tags ?? []),
+    unique(),
+    sort(compareNatural)
+  )
+  return hasAtLeast(tags, 1) ? tags : null
+}

package/src/module.ts

@@ -17,7 +17,6 @@ import {
   LikeC4DocumentLinkProvider,
   LikeC4DocumentSymbolProvider,
   LikeC4HoverProvider,
-  LikeC4RenameProvider,
   LikeC4SemanticTokenProvider
 } from './lsp'
 import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
@@ -26,6 +25,7 @@ import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references'
 import { Rpc } from './Rpc'
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared'
 import { registerValidationChecks } from './validation'
+import { LikeC4Formatter } from './formatting/LikeC4Formatter'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T
@@ -70,7 +70,7 @@ export interface LikeC4AddedServices {
     ModelChanges: LikeC4ModelChanges
   }
   lsp: {
-    RenameProvider: LikeC4RenameProvider
+    // RenameProvider: LikeC4RenameProvider
     CompletionProvider: LikeC4CompletionProvider
     DocumentHighlightProvider: LikeC4DocumentHighlightProvider
     DocumentSymbolProvider: LikeC4DocumentSymbolProvider
@@ -103,14 +103,15 @@ export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC
     ModelLocator: bind(LikeC4ModelLocator)
   },
   lsp: {
-    RenameProvider: bind(LikeC4RenameProvider),
+    // RenameProvider: bind(LikeC4RenameProvider),
     CompletionProvider: bind(LikeC4CompletionProvider),
     DocumentHighlightProvider: bind(LikeC4DocumentHighlightProvider),
     DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
     SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
     HoverProvider: bind(LikeC4HoverProvider),
     CodeLensProvider: bind(LikeC4CodeLensProvider),
-    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
+    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider),
+    Formatter: bind(LikeC4Formatter)
   },
   references: {
     ScopeComputation: bind(LikeC4ScopeComputation),
@@ -177,11 +178,7 @@ export function createLanguageServices(context: LanguageServicesContext = {}): {
   shared.ServiceRegistry.register(likec4)
   registerValidationChecks(likec4)
 
-  if (!context.connection) {
-    // We don't run inside a language server
-    // Therefore, initialize the configuration provider instantly
-    shared.workspace.ConfigurationProvider.initialized({})
-  } else {
+  if (context.connection) {
     likec4.Rpc.init()
   }