@likec4/language-server 1.2.2 → 1.3.0

package/src/model-change/ModelChanges.ts

@@ -6,34 +6,35 @@ import type { LikeC4Services } from '../module'
 import type { ChangeViewRequestParams } from '../protocol'
 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
+// 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
+//   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)
-}
+//   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
@@ -47,7 +48,7 @@ export class LikeC4ModelChanges {
     invariant(lspConnection, 'LSP Connection not available')
     let result: Location | null = null
     await this.services.shared.workspace.WorkspaceLock.write(async () => {
-      const { doc, edits } = this.convertToTextEdit(changeView)
+      const { doc, edits, modifiedRange } = this.convertToTextEdit(changeView)
       const textDocument = {
         uri: doc.textDocument.uri,
         version: doc.textDocument.version
@@ -69,52 +70,56 @@ export class LikeC4ModelChanges {
       }
       result = {
         uri: textDocument.uri,
-        range: unionRangeOfAllEdits(edits.map(edit => edit.range))
+        range: modifiedRange
       }
     })
     return result
   }
 
-  protected convertToTextEdit({ viewId, changes }: ChangeViewRequestParams): {
+  protected convertToTextEdit({ viewId, change }: ChangeViewRequestParams): {
     doc: ParsedLikeC4LangiumDocument
-    ranges: Range[]
+    modifiedRange: Range
     edits: TextEdit[]
   } {
     const lookup = this.locator.locateViewAst(viewId)
     if (!lookup) {
       throw new Error(`View not found: ${viewId}`)
     }
-    const ranges = [] as Range[]
-    const edits = [] as TextEdit[]
-    for (const change of changes) {
-      switch (change.op) {
-        case 'change-element-style': {
-          const { edits: elementEdits, modifiedRange } = changeElementStyle(this.services, {
+    switch (change.op) {
+      case 'change-element-style': {
+        return {
+          doc: lookup.doc,
+          ...changeElementStyle(this.services, {
             ...lookup,
             targets: change.targets,
             style: change.style
           })
-          ranges.push(modifiedRange)
-          edits.push(...elementEdits)
-          break
         }
-        case 'change-autolayout': {
-          const edit = changeViewLayout(this.services, {
-            ...lookup,
-            layout: change.layout
-          })
-          edits.push(edit)
-          ranges.push(edit.range)
-          break
+      }
+      case 'change-autolayout': {
+        const edit = changeViewLayout(this.services, {
+          ...lookup,
+          layout: change.layout
+        })
+        return {
+          doc: lookup.doc,
+          modifiedRange: edit.range,
+          edits: [edit]
         }
-        default:
-          nonexhaustive(change)
       }
-    }
-    return {
-      doc: lookup.doc,
-      ranges,
-      edits
+      case 'save-manual-layout':
+        const edit = saveManualLayout(this.services, {
+          ...lookup,
+          nodes: change.nodes,
+          edges: change.edges
+        })
+        return {
+          doc: lookup.doc,
+          modifiedRange: edit.range,
+          edits: [edit]
+        }
+      default:
+        nonexhaustive(change)
     }
   }
 }

package/src/model-change/changeElementStyle.ts

@@ -1,15 +1,14 @@
-import { type Fqn, invariant, isAncestor, type NonEmptyArray, nonNullable } from '@likec4/core'
+import { type Fqn, invariant, isAncestor, type NonEmptyArray, nonNullable, type ViewChanges } from '@likec4/core'
 import { GrammarUtils } from 'langium'
-import { entries, filter, findLast, isNumber, last, partition, toPairs } from 'remeda'
+import { entries, filter, findLast, last } from 'remeda'
 import { type Range, TextEdit } from 'vscode-languageserver-protocol'
-import { ast, type ParsedAstElementView, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
+import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
 import type { FqnIndex } from '../model'
 import type { LikeC4Services } from '../module'
-import type { ChangeView } from '../protocol'
 
 const { findNodeForKeyword, findNodeForProperty } = GrammarUtils
 
-const asViewStyleRule = (target: string, style: ChangeView.ChangeElementStyle['style'], indent = 0) => {
+const asViewStyleRule = (target: string, style: ViewChanges.ChangeElementStyle['style'], indent = 0) => {
   const indentStr = indent > 0 ? ' '.repeat(indent) : ''
   return [
     indentStr + `style ${target} {`,
@@ -25,7 +24,7 @@ type ChangeElementStyleArg = {
   doc: ParsedLikeC4LangiumDocument
   viewAst: ast.LikeC4View
   targets: NonEmptyArray<Fqn>
-  style: ChangeView.ChangeElementStyle['style']
+  style: ViewChanges.ChangeElementStyle['style']
 }
 
 /**

package/src/model-change/saveManualLayout.ts

@@ -0,0 +1,43 @@
+import { invariant, type ViewChanges } from '@likec4/core'
+import indentString from 'indent-string'
+import { CstUtils, GrammarUtils } from 'langium'
+import { TextEdit } from 'vscode-languageserver-protocol'
+import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
+import type { LikeC4Services } from '../module'
+import { serializeToComment } from '../view-utils/manual-layout'
+
+const { findNodeForProperty } = GrammarUtils
+
+export type ManualLayoutArg = {
+  view: ParsedAstView
+  doc: ParsedLikeC4LangiumDocument
+  viewAst: ast.LikeC4View
+  nodes: ViewChanges.SaveManualLayout['nodes']
+  edges: ViewChanges.SaveManualLayout['edges']
+}
+
+export function saveManualLayout(_services: LikeC4Services, {
+  viewAst,
+  nodes,
+  edges
+}: ManualLayoutArg): TextEdit {
+  invariant(viewAst.$cstNode, 'invalid view.$cstNode')
+  const commentCst = CstUtils.findCommentNode(viewAst.$cstNode, ['BLOCK_COMMENT'])
+  let txt = serializeToComment({ nodes, edges })
+  if (viewAst.$cstNode.range.start.character > 0) {
+    txt = indentString(txt, viewAst.$cstNode.range.start.character)
+    // const indent = ' '.repeat(viewAst.$cstNode.range.start.character)
+    // txt = txt.split('\n').map(l => indent + l).join('\n')
+  }
+  if (commentCst) {
+    // Do not indent the first line
+    return TextEdit.replace(commentCst.range, txt.trimStart())
+  }
+  return TextEdit.insert(
+    {
+      line: viewAst.$cstNode.range.start.line,
+      character: 0
+    },
+    txt + '\n'
+  )
+}

package/src/model-graph/LikeC4ModelGraph.ts

@@ -0,0 +1,304 @@
+import {
+  ancestorsFqn,
+  commonAncestor,
+  type Element,
+  type Fqn,
+  InvalidModelError,
+  invariant,
+  isSameHierarchy,
+  isString,
+  parentFqn,
+  type Relation,
+  type RelationID
+} from '@likec4/core'
+import { filter, isIncludedIn } from 'remeda'
+
+function intersection<T>(source: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T> {
+  return filter(source, isIncludedIn(other))
+}
+
+type Params = {
+  elements: Record<Fqn, Element>
+  relations: Record<RelationID, Relation>
+  // views: ElementView[]
+}
+
+type RelationEdge = {
+  source: Element
+  target: Element
+  relations: Relation[]
+}
+
+type FqnOrElement = Fqn | Element
+type FqnsOrElements = Fqn[] | Element[]
+
+export class LikeC4ModelGraph {
+  #elements = new Map<Fqn, Element>()
+  #children = new Map<Fqn, Fqn[]>()
+  #rootElements = new Set<Element>()
+
+  #relations = new Map<RelationID, Relation>()
+  // Incoming to an element or its descendants
+  #incoming = new Map<Fqn, RelationID[]>()
+  // Outgoing from an element or its descendants
+  #outgoing = new Map<Fqn, RelationID[]>()
+  // Relationships inside the element descendants
+  #internal = new Map<Fqn, RelationID[]>()
+
+  constructor({ elements, relations }: Params) {
+    for (const el of Object.values(elements)) {
+      this.addElement(el)
+    }
+    for (const rel of Object.values(relations)) {
+      this.addRelation(rel)
+    }
+  }
+
+  get rootElements() {
+    return [...this.#rootElements]
+  }
+
+  get elements() {
+    return [...this.#elements.values()]
+  }
+
+  public element(id: Fqn) {
+    const el = this.#elements.get(id)
+    invariant(el, `Element ${id} not found`)
+    return el
+  }
+
+  public incoming(id: Fqn) {
+    return this._incomingTo(id).flatMap(id => this.#relations.get(id) ?? [])
+  }
+
+  public outgoing(id: Fqn) {
+    return this._outgoingFrom(id).flatMap(id => this.#relations.get(id) ?? [])
+  }
+
+  public internal(id: Fqn) {
+    return this._internalOf(id).flatMap(id => this.#relations.get(id) ?? [])
+  }
+
+  public children(id: Fqn) {
+    return this._childrenOf(id).flatMap(id => this.#elements.get(id) ?? [])
+  }
+
+  // Get children or element itself if no children
+  public childrenOrElement(id: Fqn) {
+    const children = this.children(id)
+    return children.length > 0 ? children : [this.element(id)]
+  }
+
+  // Get all sibling (i.e. same parent)
+  public siblings(element: Fqn | Element) {
+    const id = isString(element) ? element : element.id
+    const parent = parentFqn(id)
+    const fqns = parent ? this._childrenOf(parent) : [...this.#rootElements].map(e => e.id)
+    return fqns.flatMap(fqn => (fqn !== id && this.#elements.get(fqn)) || [])
+  }
+
+  public ancestors(element: Fqn | Element) {
+    const id = isString(element) ? element : element.id
+    return ancestorsFqn(id).flatMap(id => this.#elements.get(id) ?? [])
+  }
+
+  /**
+   * Resolve siblings of the element and its ancestors
+   */
+  public ascendingSiblings(element: Fqn | Element) {
+    const id = isString(element) ? element : element.id
+    return [...this.siblings(id), ...this.ancestors(id).flatMap(a => this.siblings(a.id))]
+  }
+
+  /**
+   * Resolve all RelationEdges between element and others (any direction)
+   */
+  public anyEdgesBetween(_element: Fqn | Element, others: Fqn[] | Element[]): RelationEdge[] {
+    if (others.length === 0) {
+      return []
+    }
+    const element = isString(_element) ? this.element(_element) : _element
+    const in_element = this._incomingTo(element.id)
+    const element_out = this._outgoingFrom(element.id)
+    if (in_element.length === 0 && element_out.length === 0) {
+      return []
+    }
+
+    const result = [] as Array<RelationEdge>
+    for (const _other of others) {
+      const other = isString(_other) ? this.element(_other) : _other
+      if (isSameHierarchy(element, other)) {
+        continue
+      }
+
+      if (element_out.length > 0) {
+        const in_other = this._incomingTo(other.id)
+        const outcoming = intersection(element_out, in_other)
+        if (outcoming.length > 0) {
+          result.push({
+            source: element,
+            target: other,
+            relations: outcoming.flatMap(id => this.#relations.get(id) ?? [])
+          })
+        }
+      }
+
+      if (in_element.length > 0) {
+        const other_out = this._outgoingFrom(other.id)
+        const incoming = intersection(other_out, in_element)
+        if (incoming.length > 0) {
+          result.push({
+            source: other,
+            target: element,
+            relations: incoming.flatMap(id => this.#relations.get(id) ?? [])
+          })
+        }
+      }
+    }
+    return result
+  }
+
+  /**
+   * Resolve all RelationEdges between elements (any direction)
+   */
+  public edgesWithin<T extends Fqn[] | Element[]>(elements: T): RelationEdge[] {
+    if (elements.length < 2) {
+      return []
+    }
+    return elements.reduce((acc, el, index, array) => {
+      // return acc if last element
+      if (index === array.length - 1) {
+        return acc
+      }
+      acc.push(...this.anyEdgesBetween(el, array.slice(index + 1) as T))
+      return acc
+    }, [] as RelationEdge[])
+  }
+
+  /**
+   * Get directed RelationEdge between source and target if exists
+   */
+  public edgesBetween(
+    _sources: FqnOrElement | FqnsOrElements,
+    _targets: FqnOrElement | FqnsOrElements
+  ) {
+    const sources = Array.isArray(_sources) ? _sources : [_sources]
+    const targets = Array.isArray(_targets) ? _targets : [_targets]
+    if (sources.length === 0 || targets.length === 0) {
+      return []
+    }
+
+    const result = [] as Array<RelationEdge>
+    for (const _source of sources) {
+      const source = isString(_source) ? this.element(_source) : _source
+      const outcoming = this._outgoingFrom(source.id)
+      if (outcoming.length === 0) {
+        continue
+      }
+
+      for (const _target of targets) {
+        const target = isString(_target) ? this.element(_target) : _target
+        if (isSameHierarchy(source, target)) {
+          continue
+        }
+        const incoming = this._incomingTo(target.id)
+        if (incoming.length === 0) {
+          continue
+        }
+
+        const relations = intersection(outcoming, incoming).flatMap(
+          id => this.#relations.get(id) ?? []
+        )
+        if (relations.length > 0) {
+          result.push({
+            source,
+            target,
+            relations
+          })
+        }
+      }
+    }
+    return result
+  }
+
+  private addElement(el: Element) {
+    if (this.#elements.has(el.id)) {
+      throw new InvalidModelError(`Element ${el.id} already exists`)
+    }
+    this.#elements.set(el.id, el)
+    const parent = parentFqn(el.id)
+    if (parent) {
+      this._childrenOf(parent).push(el.id)
+    } else {
+      this.#rootElements.add(el)
+    }
+  }
+
+  private addRelation(rel: Relation) {
+    if (this.#relations.has(rel.id)) {
+      throw new InvalidModelError(`Relation ${rel.id} already exists`)
+    }
+    this.#relations.set(rel.id, rel)
+    this._incomingTo(rel.target).push(rel.id)
+    this._outgoingFrom(rel.source).push(rel.id)
+
+    const relParent = commonAncestor(rel.source, rel.target)
+    // Process internal relationships
+    if (relParent) {
+      for (const ancestor of [relParent, ...ancestorsFqn(relParent)]) {
+        this._internalOf(ancestor).push(rel.id)
+      }
+    }
+    // Process source hierarchy
+    for (const sourceAncestor of ancestorsFqn(rel.source)) {
+      if (sourceAncestor === relParent) {
+        break
+      }
+      this._outgoingFrom(sourceAncestor).push(rel.id)
+    }
+    // Process target hierarchy
+    for (const targetAncestor of ancestorsFqn(rel.target)) {
+      if (targetAncestor === relParent) {
+        break
+      }
+      this._incomingTo(targetAncestor).push(rel.id)
+    }
+  }
+
+  private _childrenOf(id: Fqn) {
+    let children = this.#children.get(id)
+    if (!children) {
+      children = []
+      this.#children.set(id, children)
+    }
+    return children
+  }
+
+  private _incomingTo(id: Fqn) {
+    let incoming = this.#incoming.get(id)
+    if (!incoming) {
+      incoming = []
+      this.#incoming.set(id, incoming)
+    }
+    return incoming
+  }
+
+  private _outgoingFrom(id: Fqn) {
+    let outgoing = this.#outgoing.get(id)
+    if (!outgoing) {
+      outgoing = []
+      this.#outgoing.set(id, outgoing)
+    }
+    return outgoing
+  }
+
+  private _internalOf(id: Fqn) {
+    let internal = this.#internal.get(id)
+    if (!internal) {
+      internal = []
+      this.#internal.set(id, internal)
+    }
+    return internal
+  }
+}