@likec4/language-server 1.19.0 → 1.19.1

package/src/validation/view-predicates/incoming.ts

@@ -1,19 +1,20 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { isNullish } from 'remeda'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const incomingExpressionChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.IncomingRelationExpression> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (ast.isWildcardExpression(el.to) && !ast.isInOutRelationExpression(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView)
       if (isNullish(view?.viewOf)) {
         accept('warning', 'Predicate is ignored as it concerns all relationships', {
-          node: el
+          node: el,
         })
       }
     }
-  }
+  })
 }

package/src/validation/view-predicates/outgoing.ts

@@ -1,19 +1,20 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { isNullish } from 'remeda'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const outgoingExpressionChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.OutgoingRelationExpression> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (ast.isWildcardExpression(el.from) && !ast.isDirectedRelationExpression(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView)
       if (isNullish(view?.viewOf)) {
         accept('warning', 'Predicate is ignored as it concerns all relationships', {
-          node: el
+          node: el,
         })
       }
     }
-  }
+  })
 }

package/src/validation/view-predicates/relation-with.ts

@@ -1,16 +1,17 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const relationPredicateWithChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.RelationPredicateWith> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
     if (ast.isExcludePredicate(container)) {
       accept('error', 'Invalid usage inside "exclude"', {
-        node: el
+        node: el,
       })
     }
-  }
+  })
 }

package/src/validation/view.ts

@@ -1,11 +1,11 @@
 import { type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
-import { RESERVED_WORDS } from './_shared'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4View> => {
   const index = services.shared.workspace.IndexManager
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     // const commentNode = CstUtils.findCommentNode(el.$cstNode, ['BLOCK_COMMENT'])
     // if (commentNode && hasManualLayout(commentNode.text) && !deserializeFromComment(commentNode.text)) {
     //   accept('warning', `Malformed @likec4-generated (ignored)`, {
@@ -19,7 +19,7 @@ export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4
     if (RESERVED_WORDS.includes(el.name)) {
       accept('error', `Reserved word: ${el.name}`, {
         node: el,
-        property: 'name'
+        property: 'name',
       })
     }
     const anotherViews = index
@@ -30,8 +30,8 @@ export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4
     if (anotherViews > 1) {
       accept('error', `Duplicate view '${el.name}'`, {
         node: el,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }

package/src/views/configurable-layouter.ts

@@ -0,0 +1,65 @@
+import { GraphvizLayouter, GraphvizWasmAdapter } from '@likec4/layouts'
+import { GraphvizBinaryAdapter } from '@likec4/layouts/graphviz/binary'
+import { isEmpty } from 'remeda'
+import which from 'which'
+import { logger } from '../logger'
+import type { LikeC4Services } from '../module'
+
+function graphvizBinPath() {
+  try {
+    return which.sync('dot')
+  } catch (error) {
+    logger.error('Error checking for native Graphviz:', error)
+    return null
+  }
+}
+
+export const ConfigurableLayouter = {
+  likec4: {
+    Layouter(services: LikeC4Services): GraphvizLayouter {
+      logger.debug('Creating ConfigurableLayouter')
+      const wasmAdapter = new GraphvizWasmAdapter()
+      const layouter = new GraphvizLayouter(wasmAdapter)
+      const langId = services.LanguageMetaData.languageId
+      services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
+        logger.debug('Configuration update', update)
+        if (update.section === langId) {
+          try {
+            const { mode, path } = update.configuration.graphviz ?? {
+              mode: 'wasm',
+              path: '',
+            }
+
+            if (mode === 'wasm') {
+              layouter.changePort(wasmAdapter)
+              logger.info('use graphviz wasm')
+              return
+            }
+
+            let binaryPath = isEmpty(path) ? graphvizBinPath() : path
+
+            if (binaryPath === null) {
+              layouter.changePort(wasmAdapter)
+              logger.warn(`No Graphviz binaries found on PATH, use graphviz wasm`)
+              services.shared.lsp.Connection?.window.showWarningMessage(
+                'No Graphviz binaries found on PATH, set path to binaries in settings.',
+              )
+              return
+            }
+
+            layouter.changePort(new GraphvizBinaryAdapter(binaryPath))
+
+            logger.info(`use graphviz binary: ${binaryPath}`)
+          } catch (error) {
+            logger.error('Failed to update configuration', error)
+          }
+          return
+        }
+
+        logger.warn('Unexpected configuration update', update)
+      })
+
+      return layouter
+    },
+  },
+}

package/src/views/index.ts

@@ -0,0 +1 @@
+export { LikeC4Views } from './likec4-views'

package/src/views/likec4-views.ts

@@ -0,0 +1,139 @@
+import type { ComputedView, DiagramView, OverviewGraph, ViewId } from '@likec4/core'
+import { GraphvizLayouter } from '@likec4/layouts'
+import { type Cancellation, type WorkspaceCache } from 'langium'
+import { values } from 'remeda'
+import { logger, logWarnError } from '../logger'
+import type { LikeC4Services } from '../module'
+
+export type GraphvizOut = {
+  dot: string
+  diagram: DiagramView
+}
+
+type GraphvizSvgOut = {
+  id: ViewId
+  dot: string
+  svg: string
+}
+
+export class LikeC4Views {
+  private cache = new WeakMap<ComputedView, GraphvizOut>()
+
+  private viewsWithReportedErrors = new Set<ViewId>()
+
+  constructor(private services: LikeC4Services) {
+  }
+
+  private get layouter(): GraphvizLayouter {
+    return this.services.likec4.Layouter
+  }
+
+  async computedViews(cancelToken?: Cancellation.CancellationToken): Promise<ComputedView[]> {
+    const model = await this.services.likec4.ModelBuilder.buildComputedModel(cancelToken)
+    return model ? values(model.views) : []
+  }
+
+  async layoutAllViews(cancelToken?: Cancellation.CancellationToken): Promise<Array<Readonly<GraphvizOut>>> {
+    const views = await this.computedViews(cancelToken)
+    if (views.length === 0) {
+      return []
+    }
+    const results = [] as GraphvizOut[]
+    const tasks = [] as Promise<GraphvizOut>[]
+    for (const view of views) {
+      this.viewsWithReportedErrors.delete(view.id)
+      tasks.push(
+        this.layouter.layout(view)
+          .then(result => {
+            this.cache.set(view, result)
+            return result
+          })
+          .catch(e => {
+            this.cache.delete(view)
+            logWarnError(e)
+            return Promise.reject(e)
+          }),
+      )
+    }
+    for (const task of await Promise.allSettled(tasks)) {
+      if (task.status === 'fulfilled') {
+        results.push(task.value)
+      }
+    }
+    return results
+  }
+
+  async layoutView(viewId: ViewId, cancelToken?: Cancellation.CancellationToken): Promise<GraphvizOut | null> {
+    const model = await this.services.likec4.ModelBuilder.buildComputedModel(cancelToken)
+    if (!model) {
+      return null
+    }
+    const view = model.views[viewId]
+    if (!view) {
+      return null
+    }
+    let cached = this.cache.get(view)
+    if (cached) {
+      return cached
+    }
+    try {
+      const result = await this.layouter.layout(view)
+      this.viewsWithReportedErrors.delete(viewId)
+      this.cache.set(view, result)
+      return result
+    } catch (e) {
+      if (!this.viewsWithReportedErrors.has(viewId)) {
+        const errMessage = e instanceof Error ? e.message : '' + e
+        this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${errMessage}`)
+        this.viewsWithReportedErrors.add(viewId)
+      }
+      logger.error(e)
+      return Promise.reject(e)
+    }
+  }
+
+  async diagrams(): Promise<Array<DiagramView>> {
+    const layouted = await this.layoutAllViews()
+    return layouted.map(l => l.diagram)
+  }
+
+  async viewsAsGraphvizOut(): Promise<Array<GraphvizSvgOut>> {
+    const KEY = 'All-LayoutedViews-DotWithSvg'
+    const cache = this.services.WorkspaceCache as WorkspaceCache<string, GraphvizSvgOut[]>
+    if (cache.has(KEY)) {
+      return await Promise.resolve(cache.get(KEY)!)
+    }
+    const views = await this.computedViews()
+    const tasks = views.map(async view => {
+      const { dot, svg } = await this.layouter.svg(view)
+      return {
+        id: view.id,
+        dot,
+        svg,
+      }
+    })
+    const succeed = [] as GraphvizSvgOut[]
+    const settledResult = await Promise.allSettled(tasks)
+    for (const result of settledResult) {
+      if (result.status === 'fulfilled') {
+        succeed.push(result.value)
+      } else {
+        logWarnError(result.reason)
+      }
+    }
+    cache.set(KEY, succeed)
+    return succeed
+  }
+
+  async overviewGraph(): Promise<OverviewGraph> {
+    const KEY = 'OverviewGraph'
+    const cache = this.services.WorkspaceCache as WorkspaceCache<string, OverviewGraph>
+    if (cache.has(KEY)) {
+      return await Promise.resolve(cache.get(KEY)!)
+    }
+    const views = await this.computedViews()
+    const overviewGraph = await this.layouter.layoutOverviewGraph(views)
+    cache.set(KEY, overviewGraph)
+    return overviewGraph
+  }
+}