@likec4/language-server 1.21.1 → 1.22.0

package/src/likec4lib.ts

@@ -1,6 +0,0 @@
-import { LibIcons } from './generated-lib/icons'
-
-export const Scheme = 'likec4builtin'
-export const Uri = `${Scheme}:///likec4/lib/icons.c4` as const
-
-export { LibIcons as Content }

package/src/logger.ts

@@ -1,80 +0,0 @@
-import { nonexhaustive } from '@likec4/core'
-import { type ConsolaReporter, formatLogObj, LogLevels, rootLogger as root } from '@likec4/log'
-import { BROWSER } from 'esm-env'
-import type { Connection } from 'vscode-languageserver'
-
-export const logger = root.withTag('lsp')
-// export const logger = root
-
-export function logError(err: unknown): void {
-  logger.error(err)
-}
-
-/**
- * Logs an error as warning (not critical)
- */
-export function logWarnError(err: unknown): void {
-  logger.warn(err)
-}
-
-export function setLogLevel(level: keyof typeof LogLevels): void {
-  logger.level = LogLevels[level]
-}
-
-export function logToLspConnection(connection: Connection): void {
-  const reporter: ConsolaReporter = {
-    log: (logObj, _ctx) => {
-      const { message, error } = formatLogObj(logObj)
-      switch (logObj.type) {
-        case 'silent': {
-          // ignore
-          break
-        }
-        case 'verbose':
-        case 'trace': {
-          connection.tracer.log(message)
-          break
-        }
-        case 'debug': {
-          connection.console.debug(message)
-          break
-        }
-        case 'log': {
-          connection.console.log(message)
-          break
-        }
-        case 'info':
-        case 'box':
-        case 'ready':
-        case 'start':
-        case 'success': {
-          connection.console.info(message)
-          break
-        }
-        case 'warn': {
-          connection.console.warn(message)
-          break
-        }
-        case 'fail':
-        case 'error':
-        case 'fatal': {
-          connection.console.error(message)
-          if (error) {
-            connection.telemetry.logEvent({ eventName: 'error', ...error })
-          } else {
-            connection.telemetry.logEvent({ eventName: 'error', message })
-          }
-          break
-        }
-        default:
-          nonexhaustive(logObj.type)
-      }
-    },
-  }
-  if (BROWSER) {
-    root.addReporter(reporter)
-  } else {
-    root.setReporters([reporter])
-  }
-  logger.setReporters(root.options.reporters)
-}

package/src/lsp/CodeLensProvider.ts

@@ -1,50 +0,0 @@
-import { DocumentState, type LangiumDocument, type MaybePromise } from 'langium'
-import type { CodeLensProvider } from 'langium/lsp'
-import type { CancellationToken, CodeLens, CodeLensParams } from 'vscode-languageserver'
-import { isParsedLikeC4LangiumDocument, ViewOps } from '../ast'
-import { logger } from '../logger'
-import type { LikeC4Services } from '../module'
-
-export class LikeC4CodeLensProvider implements CodeLensProvider {
-  constructor(private services: LikeC4Services) {
-  }
-
-  async provideCodeLens(
-    doc: LangiumDocument,
-    _params: CodeLensParams,
-    cancelToken?: CancellationToken
-  ): Promise<CodeLens[] | undefined> {
-    if (doc.state !== DocumentState.Validated) {
-      logger.debug(`Waiting for document ${doc.uri.path} to be validated`)
-      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken)
-      logger.debug(`Document ${doc.uri.path} is validated`)
-    }
-    if (!isParsedLikeC4LangiumDocument(doc)) {
-      return
-    }
-    const views = doc.parseResult.value.views.flatMap(v => v.views)
-    return views.flatMap<CodeLens>(ast => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const viewId = ViewOps.readId(ast)
-      const range = ast.$cstNode?.range
-      if (!range || !viewId) {
-        return []
-      }
-
-      return {
-        range: {
-          start: range.start,
-          end: {
-            line: range.start.line,
-            character: range.start.character + 4
-          }
-        },
-        command: {
-          command: 'likec4.open-preview',
-          arguments: [viewId],
-          title: 'open preview'
-        }
-      }
-    })
-  }
-}

package/src/lsp/CompletionProvider.ts

@@ -1,147 +0,0 @@
-import { type GrammarAST, type MaybePromise, AstUtils } from 'langium'
-import {
-  type CompletionAcceptor,
-  type CompletionContext,
-  type CompletionProviderOptions,
-  DefaultCompletionProvider,
-} from 'langium/lsp'
-import { anyPass } from 'remeda'
-import { CompletionItemKind, InsertTextFormat } from 'vscode-languageserver-types'
-import { ast } from '../ast'
-
-const STYLE_FIELDS = [
-  'color',
-  'shape',
-  'icon',
-  'border',
-  'opacity',
-  'multiple',
-  'size',
-].join(',')
-
-export class LikeC4CompletionProvider extends DefaultCompletionProvider {
-  override readonly completionOptions = {
-    triggerCharacters: ['.'],
-  } satisfies CompletionProviderOptions
-
-  protected override completionForKeyword(
-    context: CompletionContext,
-    keyword: GrammarAST.Keyword,
-    acceptor: CompletionAcceptor,
-  ): MaybePromise<void> {
-    if (!this.filterKeyword(context, keyword)) {
-      return
-    }
-    if (keyword.value === 'deployment' && AstUtils.hasContainerOfType(context.node, ast.isModelViews)) {
-      return acceptor(context, {
-        label: keyword.value,
-        detail: `Insert deployment view`,
-        kind: CompletionItemKind.Class,
-        insertTextFormat: InsertTextFormat.Snippet,
-        insertText: [
-          'deployment view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {',
-          '\ttitle \'${2:Untitled}\'',
-          '\t',
-          '\tinclude $0',
-          '}',
-        ].join('\n'),
-      })
-    }
-    if (['title', 'description', 'technology'].includes(keyword.value)) {
-      return acceptor(context, {
-        label: keyword.value,
-        kind: CompletionItemKind.Property,
-        insertTextFormat: InsertTextFormat.Snippet,
-        insertText: `${keyword.value} '\${0}'`,
-      })
-    }
-    if (['views', 'specification', 'model', 'deployment', 'with'].includes(keyword.value)) {
-      return acceptor(context, {
-        label: keyword.value,
-        detail: `Insert ${keyword.value} block`,
-        kind: CompletionItemKind.Module,
-        insertTextFormat: InsertTextFormat.Snippet,
-        insertText: `${keyword.value} {\n\t$0\n}`,
-      })
-    }
-    if (keyword.value === 'group') {
-      return acceptor(context, {
-        label: keyword.value,
-        detail: `Insert group block`,
-        kind: CompletionItemKind.Class,
-        insertTextFormat: InsertTextFormat.Snippet,
-        insertText: [
-          'group \'${1:Title}\' {',
-          '\t$0',
-          '}',
-        ].join('\n'),
-      })
-    }
-    if (keyword.value === 'dynamic' && AstUtils.hasContainerOfType(context.node, ast.isModelViews)) {
-      return acceptor(context, {
-        label: keyword.value,
-        detail: `Insert dynamic view`,
-        kind: CompletionItemKind.Class,
-        insertTextFormat: InsertTextFormat.Snippet,
-        insertText: [
-          'dynamic view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {',
-          '\ttitle \'${2:Untitled}\'',
-          '\t',
-          '\t$0',
-          '}',
-        ].join('\n'),
-      })
-    }
-    if (keyword.value === 'style' && context.node) {
-      if (AstUtils.hasContainerOfType(context.node, ast.isGlobalStyle)) {
-        return acceptor(context, {
-          label: keyword.value,
-          detail: `Insert ${keyword.value} block`,
-          kind: CompletionItemKind.Module,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1:name} \${2:*} {\n\t\${3|${STYLE_FIELDS}|} $0\n}`,
-        })
-      }
-      if (AstUtils.hasContainerOfType(context.node, anyPass([ast.isModelViews, ast.isGlobalStyleGroup]))) {
-        return acceptor(context, {
-          label: keyword.value,
-          detail: `Insert ${keyword.value} block`,
-          kind: CompletionItemKind.Module,
-          insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1:*} {\n\t\${2|${STYLE_FIELDS}|} $0\n}`,
-        })
-      }
-      return acceptor(context, {
-        label: keyword.value,
-        detail: `Insert ${keyword.value} block`,
-        kind: CompletionItemKind.Module,
-        insertTextFormat: InsertTextFormat.Snippet,
-        insertText: `${keyword.value} {\n\t\${1|${STYLE_FIELDS}|} $0\n}`,
-      })
-    }
-    if (keyword.value === 'extend') {
-      return acceptor(context, {
-        label: keyword.value,
-        detail: `Extend another view`,
-        kind: CompletionItemKind.Class,
-        insertTextFormat: InsertTextFormat.Snippet,
-        insertText: 'extend ${1:element} {\n\t$0\n}',
-      })
-    }
-
-    if (keyword.value === 'autoLayout') {
-      return acceptor(context, {
-        label: keyword.value,
-        kind: CompletionItemKind.Class,
-        insertTextFormat: InsertTextFormat.Snippet,
-        insertText: 'autoLayout ${1|TopBottom,BottomTop,LeftRight,RightLeft|}$0',
-      })
-    }
-    acceptor(context, {
-      label: keyword.value,
-      kind: this.getKeywordCompletionItemKind(keyword),
-      detail: 'Keyword',
-      sortText: '1',
-    })
-  }
-}

package/src/lsp/DocumentHighlightProvider.ts

@@ -1,12 +0,0 @@
-import type { ReferenceDescription } from 'langium'
-import { DefaultDocumentHighlightProvider } from 'langium/lsp'
-import { DocumentHighlight, DocumentHighlightKind } from 'vscode-languageserver'
-
-export class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
-  /**
-   * Override this method to determine the highlight kind of the given reference.
-   */
-  protected override createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight {
-    return DocumentHighlight.create(reference.segment.range, DocumentHighlightKind.Read)
-  }
-}

package/src/lsp/DocumentLinkProvider.ts

@@ -1,65 +0,0 @@
-import type { LangiumDocument, MaybePromise } from 'langium'
-import { AstUtils, GrammarUtils } from 'langium'
-import type { DocumentLinkProvider } from 'langium/lsp'
-import { hasLeadingSlash, hasProtocol, isRelative, withoutBase, withoutLeadingSlash } from 'ufo'
-import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver'
-import { ast, isParsedLikeC4LangiumDocument } from '../ast'
-import { logWarnError } from '../logger'
-import type { LikeC4Services } from '../module'
-
-export class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
-  constructor(private services: LikeC4Services) {
-    //
-  }
-  getDocumentLinks(
-    doc: LangiumDocument,
-    _params: DocumentLinkParams
-  ): MaybePromise<DocumentLink[]> {
-    if (!isParsedLikeC4LangiumDocument(doc)) {
-      return []
-    }
-    return AstUtils.streamAllContents(doc.parseResult.value)
-      .filter(ast.isLinkProperty)
-      .map((n): DocumentLink | null => {
-        try {
-          const range = GrammarUtils.findNodeForProperty(n.$cstNode, 'value')?.range
-          const target = this.resolveLink(doc, n.value)
-          if (range && hasProtocol(target)) {
-            return {
-              range,
-              target
-            }
-          }
-        } catch (e) {
-          logWarnError(e)
-        }
-        return null
-      })
-      .nonNullable()
-      .toArray()
-  }
-
-  resolveLink(doc: LangiumDocument, link: string): string {
-    if (hasProtocol(link) || hasLeadingSlash(link)) {
-      return link
-    }
-    const base = isRelative(link)
-      ? new URL(doc.uri.toString(true))
-      : this.services.shared.workspace.WorkspaceManager.workspaceURL
-    return new URL(link, base).toString()
-  }
-
-  relativeLink(doc: LangiumDocument, link: string): string | null {
-    if (hasLeadingSlash(link)) {
-      return withoutLeadingSlash(link)
-    }
-    if (isRelative(link)) {
-      const base = new URL(doc.uri.toString(true))
-      const linkURL = new URL(link, base).toString()
-      return withoutLeadingSlash(
-        withoutBase(linkURL, this.services.shared.workspace.WorkspaceManager.workspaceURL.toString())
-      )
-    }
-    return null
-  }
-}

package/src/lsp/DocumentSymbolProvider.ts

@@ -1,313 +0,0 @@
-import { nonexhaustive } from '@likec4/core'
-import { type AstNode, type MaybePromise, AstUtils, GrammarUtils } from 'langium'
-import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp'
-import { filter, isEmpty, isTruthy, map, pipe } from 'remeda'
-import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types'
-import { type LikeC4LangiumDocument, ast } from '../ast'
-import { logError, logWarnError } from '../logger'
-import type { LikeC4ModelLocator, LikeC4ModelParser } from '../model'
-import type { LikeC4Services } from '../module'
-import type { LikeC4NameProvider } from '../references'
-import { getFqnElementRef } from '../utils/elementRef'
-
-export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
-  protected readonly nodeKindProvider: NodeKindProvider
-  protected readonly nameProvider: LikeC4NameProvider
-  protected readonly parser: LikeC4ModelParser
-  protected readonly locator: LikeC4ModelLocator
-
-  constructor(private services: LikeC4Services) {
-    this.nodeKindProvider = services.shared.lsp.NodeKindProvider
-    this.parser = services.likec4.ModelParser
-    this.locator = services.likec4.ModelLocator
-    this.nameProvider = services.references.NameProvider
-  }
-
-  getSymbols({
-    parseResult: {
-      value: { specifications, models, deployments, views, likec4lib },
-    },
-  }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]> {
-    return [
-      ...likec4lib.map(l => () => this.getLikec4LibSymbol(l)),
-      ...specifications.map(s => () => this.getSpecSymbol(s)),
-      ...models.map(s => () => this.getModelSymbol(s)),
-      ...deployments.map(s => () => this.getDeploymentModelSymbol(s)),
-      ...views.map(s => () => this.getModelViewsSymbol(s)),
-    ].flatMap(fn => {
-      try {
-        return fn() ?? []
-      } catch (e) {
-        logWarnError(e)
-        return []
-      }
-    })
-  }
-
-  protected getLikec4LibSymbol(astLib: ast.LikeC4Lib): DocumentSymbol[] {
-    const cstModel = astLib?.$cstNode
-    if (!cstModel) return []
-    const children = astLib.icons.map(i => this.getLibIconSymbol(i)).filter(isTruthy)
-    if (children.length === 0) return []
-    return [
-      {
-        kind: SymbolKind.Namespace,
-        name: 'icons',
-        range: cstModel.range,
-        selectionRange: GrammarUtils.findNodeForKeyword(cstModel, 'icons')?.range ?? cstModel.range,
-        children,
-      },
-    ]
-  }
-
-  protected getSpecSymbol(astSpec: ast.SpecificationRule): DocumentSymbol[] {
-    const cstModel = astSpec?.$cstNode
-    if (!cstModel) return []
-    const specKeywordNode = GrammarUtils.findNodeForProperty(cstModel, 'name')
-    if (!specKeywordNode) return []
-
-    const specSymbols = pipe(
-      [...astSpec.elements, ...astSpec.tags, ...astSpec.relationships],
-      map(nd => {
-        try {
-          if (
-            ast.isSpecificationElementKind(nd) || ast.isSpecificationRelationshipKind(nd)
-            || ast.isSpecificationDeploymentNodeKind(nd)
-          ) {
-            return this.getKindSymbol(nd)
-          }
-          if (ast.isSpecificationTag(nd)) {
-            return this.getTagSymbol(nd)
-          }
-        } catch (e) {
-          logWarnError(e)
-          return null
-        }
-        nonexhaustive(nd)
-      }),
-      filter(isTruthy),
-    )
-
-    if (specSymbols.length === 0) return []
-
-    return [
-      {
-        kind: SymbolKind.Namespace,
-        name: astSpec.name,
-        range: cstModel.range,
-        selectionRange: specKeywordNode.range,
-        children: specSymbols,
-      },
-    ]
-  }
-
-  protected getModelSymbol(astModel: ast.Model): DocumentSymbol[] {
-    const cstModel = astModel.$cstNode
-    if (!cstModel) return []
-    const nameNode = GrammarUtils.findNodeForProperty(cstModel, 'name')
-    if (!nameNode) return []
-    return [
-      {
-        kind: this.symbolKind(astModel),
-        name: astModel.name,
-        range: cstModel.range,
-        selectionRange: nameNode.range,
-        children: astModel.elements.flatMap(e => this.getElementsSymbol(e)),
-      },
-    ]
-  }
-
-  protected getDeploymentModelSymbol(astModel: ast.ModelDeployments): DocumentSymbol[] {
-    const cstModel = astModel.$cstNode
-    if (!cstModel) return []
-    const nameNode = GrammarUtils.findNodeForProperty(cstModel, 'name')
-    if (!nameNode) return []
-    return [
-      {
-        kind: this.symbolKind(astModel),
-        name: astModel.name,
-        range: cstModel.range,
-        selectionRange: nameNode.range,
-        children: astModel.elements.flatMap(e => this.getDeploymentElementSymbol(e)),
-      },
-    ]
-  }
-
-  protected getElementsSymbol(
-    el: ast.Element | ast.Relation | ast.ExtendElement,
-  ): DocumentSymbol[] {
-    try {
-      if (ast.isExtendElement(el)) {
-        return this.getExtendElementSymbol(el)
-      }
-      if (ast.isElement(el)) {
-        return this.getElementSymbol(el)
-      }
-    } catch (e) {
-      logWarnError(e)
-    }
-    return []
-  }
-
-  protected getExtendElementSymbol(astElement: ast.ExtendElement): DocumentSymbol[] {
-    const cst = astElement.$cstNode
-    const nameNode = astElement.element.$cstNode
-    const body = astElement.body
-    if (!cst || !nameNode) return []
-
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name: getFqnElementRef(astElement.element),
-        range: cst.range,
-        selectionRange: nameNode.range,
-        children: body.elements.flatMap(e => this.getElementsSymbol(e)),
-      },
-    ]
-  }
-
-  protected getElementSymbol(astElement: ast.Element): DocumentSymbol[] {
-    const cst = astElement.$cstNode
-    const nameNode = GrammarUtils.findNodeForProperty(cst, 'name')
-    if (!nameNode || !cst) return []
-
-    const name = astElement.name
-    const kind = astElement.kind.$refText
-    // TODO: return the title as well
-    const detail = kind // + (astElement.title ? ': ' + astElement.title : '').replaceAll('\n', ' ').trim()
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name: name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        detail,
-        children: astElement.body?.elements.flatMap(e => this.getElementsSymbol(e)) ?? [],
-      },
-    ]
-  }
-  protected getModelViewsSymbol(astViews: ast.ModelViews): DocumentSymbol[] {
-    const cst = astViews.$cstNode
-    const nameNode = GrammarUtils.findNodeForProperty(cst, 'name')
-    if (!nameNode || !cst) return []
-    return [
-      {
-        kind: this.symbolKind(astViews),
-        name: astViews.name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        children: astViews.views.flatMap(e => this.getViewSymbol(e)),
-      },
-    ]
-  }
-
-  protected getKindSymbol(
-    astKind: ast.SpecificationElementKind | ast.SpecificationRelationshipKind,
-  ): DocumentSymbol | null {
-    if (!astKind.$cstNode || !astKind.kind.$cstNode || isEmpty(astKind.kind.name)) return null
-
-    return {
-      kind: this.symbolKind(astKind),
-      name: astKind.kind.name,
-      range: astKind.$cstNode.range,
-      selectionRange: astKind.kind.$cstNode.range,
-    }
-  }
-
-  protected getTagSymbol(astTag: ast.SpecificationTag): DocumentSymbol | null {
-    if (!astTag.$cstNode || !astTag.tag.$cstNode || isEmpty(astTag.tag.name)) return null
-    return {
-      kind: this.symbolKind(astTag),
-      name: '#' + astTag.tag.name,
-      range: astTag.$cstNode.range,
-      selectionRange: astTag.tag.$cstNode.range,
-    }
-  }
-
-  protected getLibIconSymbol(astTag: ast.LibIcon): DocumentSymbol | null {
-    if (!astTag.$cstNode || isEmpty(astTag.name)) return null
-    return {
-      kind: this.symbolKind(astTag),
-      name: astTag.name,
-      range: astTag.$cstNode.range,
-      selectionRange: astTag.$cstNode.range,
-    }
-  }
-
-  protected getViewSymbol(astView: ast.LikeC4View): DocumentSymbol[] {
-    const cst = astView?.$cstNode
-    if (!cst) return []
-    const nameNode = astView.name ? GrammarUtils.findNodeForProperty(cst, 'name') : null
-    if (!nameNode) return []
-    return [
-      {
-        kind: this.symbolKind(astView),
-        name: nameNode.text,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        children: [],
-      },
-    ]
-  }
-
-  protected getDeploymentElementSymbol(el: ast.DeploymentElement | ast.DeploymentRelation): DocumentSymbol[] {
-    try {
-      if (ast.isDeploymentNode(el)) {
-        return this.getDeploymentNodeSymbol(el)
-      }
-      if (ast.isDeployedInstance(el)) {
-        return this.getDeployedInstanceSymbol(el)
-      }
-    } catch (e) {
-      logWarnError(e)
-    }
-    return []
-  }
-
-  protected getDeploymentNodeSymbol(astElement: ast.DeploymentNode): DocumentSymbol[] {
-    const cst = astElement.$cstNode
-    const nameNode = this.nameProvider.getNameNode(astElement)
-    if (!nameNode || !cst) return []
-
-    const name = this.nameProvider.getNameStrict(astElement)
-    const kind = astElement.kind.$refText
-    // TODO: return the title as well
-    const detail = kind // + (astElement.title ? ': ' + astElement.title : '').replaceAll('\n', ' ').trim()
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name: name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        detail,
-        children: astElement.body?.elements.flatMap(e => this.getDeploymentElementSymbol(e)) ?? [],
-      },
-    ]
-  }
-
-  protected getDeployedInstanceSymbol(astElement: ast.DeployedInstance): DocumentSymbol[] {
-    const cst = astElement.$cstNode
-    const nameNode = this.nameProvider.getNameNode(astElement)
-    if (!nameNode || !cst) return []
-
-    const doc = AstUtils.getDocument(astElement)
-    const instance = this.parser.forDocument(doc).parseDeployedInstance(astElement)
-
-    const name = this.nameProvider.getNameStrict(astElement)
-    const detail = 'instance of ' + instance.element
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name: name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        detail,
-        children: [],
-      },
-    ]
-  }
-
-  protected symbolKind(node: AstNode): SymbolKind {
-    return this.nodeKindProvider.getSymbolKind(node)
-  }
-}