@likec4/language-server 1.8.1 → 1.10.0

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

@@ -1,4 +1,5 @@
 import type {
+  Color,
   ComputedEdge,
   ComputedElementView,
   EdgeId,
@@ -12,7 +13,7 @@ import type {
   RelationshipKind,
   RelationshipLineType,
   Tag,
-  ThemeColor,
+  ViewID,
   ViewRulePredicate
 } from '@likec4/core'
 import {
@@ -29,7 +30,7 @@ import {
   parentFqn,
   whereOperatorAsPredicate
 } from '@likec4/core'
-import { first, flatMap, hasAtLeast, isTruthy, map, omit, unique } from 'remeda'
+import { filter, flatMap, 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'
@@ -191,7 +192,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
 
@@ -204,67 +205,78 @@ 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?: ThemeColor | 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 = relations.length === 1 ? relations[0] : relations.find(r => r.source === source && r.target === target)
 
       // 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 ?? []))
@@ -273,12 +285,13 @@ export class ComputeCtx {
         edge,
         this.getEdgeLabel(relation),
         isTruthy(relation.description) && { description: relation.description },
-        isTruthy(relation.technology) && { description: relation.technology },
+        isTruthy(relation.technology) && { technology: relation.technology },
         isTruthy(relation.kind) && { kind: relation.kind },
         relation.color && { color: relation.color },
         relation.line && { line: relation.line },
         relation.head && { head: relation.head },
         relation.tail && { tail: relation.tail },
+        relation.navigateTo && { navigateTo: relation.navigateTo },
         hasAtLeast(tags, 1) && { tags }
       )
     })
@@ -348,29 +361,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()
@@ -537,19 +561,24 @@ export class ComputeCtx {
       return this
     }
     nonexhaustive(expr)
-  }  
+  }
 
-  protected getEdgeLabel(relation: { title: String | undefined, technology?: String | undefined }): { label: String } | false {
-    const labelParts: String[] = []
+  protected getEdgeLabel(
+    relation: {
+      title: string
+      technology?: string | undefined
+    }
+  ) {
+    const labelParts: string[] = []
 
-    if(isTruthy(relation.title)) {
+    if (isTruthy(relation.title)) {
       labelParts.push(relation.title)
     }
 
-    if(isTruthy(relation.technology)) {
+    if (isTruthy(relation.technology)) {
       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'
 
@@ -306,25 +306,23 @@ function edgesIncomingExpr(this: ComputeCtx, expr: Expr.ElementExpression) {
   return this.graph.edgesBetween(sources, targets)
 }
 
-const filterEdges = (edges: ComputeCtx.Edge[], where?: RelationPredicateFn) => {
+const filterEdges = (edges: ReadonlyArray<ComputeCtx.Edge>, where?: RelationPredicateFn) => {
   if (!where) {
-    return edges
+    return edges as ComputeCtx.Edge[]
   }
   return pipe(
     edges,
     map(e => ({ ...e, relations: e.relations.filter(where) })),
     remedaFilter(e => e.relations.length > 0)
-  )
+  ) as ComputeCtx.Edge[]
 }
 
 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/__test__/fixture.ts

@@ -10,6 +10,7 @@ const emptyView = {
   description: null,
   tags: null,
   links: null,
+  customColorDefinitions: {},
   rules: []
 }
 

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

@@ -1,14 +1,16 @@
 import type {
+  Color,
   ComputedDynamicView,
   ComputedEdge,
   DynamicView,
+  DynamicViewStep,
   Element,
   NonEmptyArray,
   RelationID,
   RelationshipArrowType,
   RelationshipLineType,
   Tag,
-  ThemeColor
+  ViewID
 } from '@likec4/core'
 import {
   ancestorsFqn,
@@ -17,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'
@@ -33,17 +36,19 @@ import { elementExprToPredicate } from '../utils/elementExpressionToPredicate'
 
 export namespace DynamicViewComputeCtx {
   export interface Step {
+    id: StepEdgeId
     source: Element
     target: Element
     title: string | null
     description?: string
     technology?: string
-    color?: ThemeColor
+    color?: Color
     line?: RelationshipLineType
     head?: RelationshipArrowType
     tail?: RelationshipArrowType
     relations: RelationID[]
     isBackward: boolean
+    navigateTo?: ViewID
     tags?: NonEmptyArray<Tag>
   }
 }
@@ -62,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
@@ -70,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) {
@@ -110,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,
@@ -182,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/elementExpressionToPredicate.ts

@@ -1,5 +1,5 @@
 import { Expr, nonexhaustive, parentFqn } from '@likec4/core'
-import { type Element, whereOperatorAsPredicate } from '@likec4/core/types'
+import { type Element, whereOperatorAsPredicate } from '@likec4/core'
 import { isNullish } from 'remeda'
 
 type Predicate<T> = (x: T) => boolean

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

@@ -1,4 +1,3 @@
-import pkg from '@dagrejs/graphlib'
 import {
   compareByFqnHierarchically,
   compareRelations,
@@ -10,10 +9,7 @@ import {
   nonNullable
 } from '@likec4/core'
 import { difference, filter, map, pipe, sort, take } from 'remeda'
-
-// '@dagrejs/graphlib' is a CommonJS module
-// Here is a workaround to import it
-const { Graph, alg } = pkg
+import { Graph, postorder } from '../../utils/graphlib'
 
 // side effect
 function sortChildren(nodes: readonly ComputedNode[]) {
@@ -92,7 +88,7 @@ export function sortNodes({
       map(n => n.id)
     )
   }
-  const orderedIds = alg.postorder(g, sources).reverse() as Fqn[]
+  const orderedIds = postorder(g, sources).reverse() as Fqn[]
   const sorted = orderedIds.map(getNode)
   if (sorted.length < nodes.length) {
     const unsorted = difference(nodes, sorted)