@likec4/language-server 1.21.1 → 1.22.0

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

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

package/src/validation/view.ts

@@ -1,37 +0,0 @@
-import { type ValidationCheck } from 'langium'
-import { ast } from '../ast'
-import type { LikeC4Services } from '../module'
-import { RESERVED_WORDS, tryOrLog } from './_shared'
-
-export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4View> => {
-  const index = services.shared.workspace.IndexManager
-  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)`, {
-    //     node: el,
-    //     range: commentNode.range
-    //   })
-    // }
-    if (!el.name) {
-      return
-    }
-    if (RESERVED_WORDS.includes(el.name)) {
-      accept('error', `Reserved word: ${el.name}`, {
-        node: el,
-        property: 'name',
-      })
-    }
-    const anotherViews = index
-      .allElements(ast.LikeC4View)
-      .filter(n => n.name === el.name)
-      .limit(2)
-      .count()
-    if (anotherViews > 1) {
-      accept('error', `Duplicate view '${el.name}'`, {
-        node: el,
-        property: 'name',
-      })
-    }
-  })
-}

package/src/view-utils/assignNavigateTo.ts

@@ -1,31 +0,0 @@
-import { ComputedNode, ComputedView, type Fqn, type ViewId } from '@likec4/core'
-import { find, isNullish } from 'remeda'
-
-export function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R {
-  const allElementViews = new Map<Fqn, ViewId[]>()
-
-  for (const v of views) {
-    if (ComputedView.isElement(v) && v.viewOf && isNullish(v.extends)) {
-      const viewsOf = allElementViews.get(v.viewOf) ?? []
-      viewsOf.push(v.id)
-      allElementViews.set(v.viewOf, viewsOf)
-    }
-  }
-
-  // set default navigateTo
-  for (const { id, nodes } of views) {
-    for (const node of nodes) {
-      const modelRef = ComputedNode.modelRef(node)
-      if (node.navigateTo || !modelRef) {
-        continue
-      }
-      // find first element view that is not the current one
-      const navigateTo = find(allElementViews.get(modelRef) ?? [], v => v !== id)
-      if (navigateTo) {
-        node.navigateTo = navigateTo
-      }
-    }
-  }
-
-  return views
-}

package/src/view-utils/index.ts

@@ -1,2 +0,0 @@
-export * from './assignNavigateTo'
-export * from './resolve-relative-paths'

package/src/view-utils/manual-layout.ts

@@ -1,116 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { isAutoLayoutDirection, type ViewManualLayout } from '@likec4/core'
-import { decode, encode } from '@msgpack/msgpack'
-import { fromBase64, toBase64 } from '@smithy/util-base64'
-import { AstUtils, CstUtils } from 'langium'
-import { mapValues } from 'remeda'
-import type { ast } from '../ast'
-import { logger } from '../logger'
-
-const { getDocument } = AstUtils
-
-function pack({
-  nodes,
-  edges,
-  ...rest
-}: ViewManualLayout) {
-  return {
-    ...rest,
-    nodes: mapValues(nodes, ({ x, y, width, height, isCompound, ...n }) => ({
-      ...n,
-      b: [x, y, width, height] as const,
-      c: isCompound
-    })),
-    edges: mapValues(edges, ({ points, controlPoints, labelBBox, dotpos, ...e }) => ({
-      ...!!controlPoints && { cp: controlPoints },
-      ...!!labelBBox && { l: labelBBox },
-      ...!!dotpos && { dp: dotpos },
-      ...e,
-      p: points
-    }))
-  }
-}
-
-function unpack({
-  nodes,
-  edges,
-  autoLayout,
-  ...rest
-}: ReturnType<typeof pack>): ViewManualLayout {
-  return {
-    ...rest,
-    /// Try to parse the old format for backward compatibility
-    autoLayout: isAutoLayoutDirection(autoLayout) ? { direction: autoLayout } : autoLayout,
-    nodes: mapValues(nodes, ({ b, c, ...n }) => ({
-      x: b[0],
-      y: b[1],
-      width: b[2],
-      height: b[3],
-      isCompound: c,
-      ...n
-    })),
-    edges: mapValues(edges, ({ p, cp, l, dp, ...e }) => ({
-      ...!!cp && { controlPoints: cp },
-      ...!!l && { labelBBox: l },
-      ...!!dp && { dotpos: dp },
-      ...e,
-      points: p
-    }))
-  }
-}
-
-const MAX_LINE_LENGTH = 500
-export function serializeToComment(layout: ViewManualLayout) {
-  const bytes = encode(pack(layout))
-  const base64 = toBase64(bytes)
-  const lines = [] as string[]
-  let offset = 0
-  while (offset < base64.length) {
-    lines.push(' * ' + base64.slice(offset, Math.min(offset + MAX_LINE_LENGTH, base64.length)))
-    offset += MAX_LINE_LENGTH
-  }
-  lines.unshift(
-    '/**',
-    ' * @likec4-generated(v1)'
-  )
-  lines.push(' */')
-
-  return lines.join('\n')
-}
-
-export function hasManualLayout(comment: string) {
-  return comment.includes('@likec4-generated')
-}
-
-export function deserializeFromComment(comment: string): ViewManualLayout {
-  if (!hasManualLayout(comment)) {
-    throw new Error(`Not a likec4-generated comment: ${comment}`)
-  }
-  const b64 = comment
-    .trim()
-    .split('\n')
-    .filter(l => !l.includes('**') && !l.includes('@likec4-') && !l.includes('*/'))
-    .map(l => l.replaceAll('*', '').trim())
-    .join('')
-  const decodedb64 = fromBase64(b64)
-  return unpack(decode(decodedb64) as any) as ViewManualLayout
-}
-
-export function parseViewManualLayout(node: ast.LikeC4View): c4.ViewManualLayout | undefined {
-  const commentNode = CstUtils.findCommentNode(node.$cstNode, ['BLOCK_COMMENT'])
-  if (!commentNode || !hasManualLayout(commentNode.text)) {
-    return undefined
-  }
-  try {
-    return deserializeFromComment(commentNode.text)
-  } catch (e) {
-    const doc = getDocument(node)
-    logger.warn(e)
-    logger.warn(
-      `Ignoring manual layout of "${node.name ?? 'unnamed'}" at ${doc.uri.fsPath}:${
-        1 + (commentNode.range.start.line || 0)
-      }`
-    )
-    return undefined
-  }
-}

package/src/view-utils/resolve-relative-paths.ts

@@ -1,90 +0,0 @@
-import type { LikeC4View } from '@likec4/core'
-import { compareNatural, invariant } from '@likec4/core'
-import { filter, hasAtLeast, isTruthy, map, pipe, unique } from 'remeda'
-import { parsePath } from 'ufo'
-
-function commonAncestorPath(views: LikeC4View[], sep = '/') {
-  const uniqURIs = pipe(
-    views,
-    map(v => v.docUri),
-    filter(isTruthy),
-    unique()
-  )
-  if (uniqURIs.length === 0) return ''
-  if (uniqURIs.length === 1) {
-    const parts = parsePath(uniqURIs[0]).pathname.split(sep)
-    if (parts.length <= 1) return sep
-    parts.pop() // remove filename
-    return parts.join(sep) + sep
-  }
-  invariant(hasAtLeast(uniqURIs, 2), 'Expected at least 2 unique URIs')
-  const [baseUri, ...tail] = uniqURIs
-  const parts = parsePath(baseUri).pathname.split(sep)
-  let endOfPrefix = parts.length
-  for (const uri of tail) {
-    if (uri === baseUri) {
-      continue
-    }
-    const compare = parsePath(uri).pathname.split(sep)
-    for (let i = 0; i < endOfPrefix; i++) {
-      if (compare[i] !== parts[i]) {
-        endOfPrefix = i
-      }
-    }
-    if (endOfPrefix === 0) return ''
-  }
-  const prefix = parts.slice(0, endOfPrefix).join(sep)
-  return prefix.endsWith(sep) ? prefix : prefix + sep
-}
-
-export function resolveRelativePaths(views: LikeC4View[]): LikeC4View[] {
-  const sep = '/'
-  const commonPrefix = commonAncestorPath(views, sep)
-  return (
-    views
-      // For each view, compute the relative path to the common prefix
-      // Store array of path segments
-      .map(view => {
-        if (!view.docUri) {
-          return {
-            view,
-            parts: []
-          }
-        }
-        let path = parsePath(view.docUri).pathname
-        if (commonPrefix.length > 0) {
-          invariant(
-            path.startsWith(commonPrefix),
-            `Expect path "${path}" to start with common prefix: "${commonPrefix}"`
-          )
-          path = path.slice(commonPrefix.length)
-        } else {
-          path = path.includes(sep) ? path.slice(path.lastIndexOf(sep) + 1) : path
-        }
-        return {
-          view,
-          parts: path.split(sep)
-        }
-      })
-      // Sort views by path segments
-      .sort((a, b) => {
-        if (a.parts.length !== b.parts.length) {
-          return a.parts.length - b.parts.length
-        }
-        for (let i = 0; i < a.parts.length; i++) {
-          const compare = compareNatural(a.parts[i], b.parts[i])
-          if (compare !== 0) {
-            return compare
-          }
-        }
-        return compareNatural(a.view.title ?? a.view.id, b.view.title ?? b.view.id)
-      })
-      // Build relativePath from path segments
-      .map(({ parts, view }) => {
-        return {
-          ...view,
-          relativePath: parts.join(sep)
-        }
-      })
-  )
-}

package/src/views/configurable-layouter.ts

@@ -1,65 +0,0 @@
-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

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

package/src/views/likec4-views.ts

@@ -1,139 +0,0 @@
-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
-  }
-}