@likec4/language-server 1.21.1 → 1.22.0

package/src/model-change/changeViewLayout.ts

@@ -1,47 +0,0 @@
-import { invariant, type ViewChange } from '@likec4/core'
-import { GrammarUtils } from 'langium'
-import { findLast, isNumber } from 'remeda'
-import { TextEdit } from 'vscode-languageserver-types'
-import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument, toAstViewLayoutDirection } from '../ast'
-import type { LikeC4Services } from '../module'
-
-const { findNodeForProperty, findNodeForKeyword } = GrammarUtils
-
-type ChangeViewLayoutArg = {
-  view: ParsedAstView
-  doc: ParsedLikeC4LangiumDocument
-  viewAst: ast.LikeC4View
-  layout: ViewChange.ChangeAutoLayout['layout']
-}
-
-export function changeViewLayout(_services: LikeC4Services, {
-  view,
-  viewAst,
-  layout
-}: ChangeViewLayoutArg): TextEdit {
-  // Should never happen
-  invariant(viewAst.body, `View ${view.id} has no body`)
-  const viewCstNode = viewAst.$cstNode
-  invariant(viewCstNode, 'viewCstNode')
-  const newdirection = toAstViewLayoutDirection(layout.direction)
-  const existingRule = findLast(viewAst.body.rules, ast.isViewRuleAutoLayout) as ast.ViewRuleAutoLayout | undefined
-
-  let newRule = `autoLayout ${newdirection}`
-
-  if (isNumber(layout.rankSep)) {
-    newRule += ` ${layout.rankSep}`
-    if (isNumber(layout.nodeSep)) {
-      newRule += ` ${layout.nodeSep}`
-    }
-  }
-
-  if (existingRule && existingRule.$cstNode) {
-    return TextEdit.replace(existingRule.$cstNode.range, newRule)
-  }
-
-  const insertPos = findNodeForKeyword(viewAst.body.$cstNode, '}')?.range.start
-  invariant(insertPos, 'Closing brace not found')
-  const insert = `\t${newRule}\n\t`
-
-  return TextEdit.insert(insertPos, insert)
-}

package/src/model-change/saveManualLayout.ts

@@ -1,41 +0,0 @@
-import { invariant, type ViewChange } from '@likec4/core'
-import indentString from 'indent-string'
-import { CstUtils, GrammarUtils } from 'langium'
-import { TextEdit } from 'vscode-languageserver-types'
-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
-  layout: ViewChange.SaveManualLayout['layout']
-}
-
-export function saveManualLayout(_services: LikeC4Services, {
-  viewAst,
-  layout
-}: ManualLayoutArg): TextEdit {
-  invariant(viewAst.$cstNode, 'invalid view.$cstNode')
-  const commentCst = CstUtils.findCommentNode(viewAst.$cstNode, ['BLOCK_COMMENT'])
-  let txt = serializeToComment(layout)
-  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/module.ts

@@ -1,255 +0,0 @@
-import { GraphvizLayouter, GraphvizWasmAdapter } from '@likec4/layouts'
-import {
-  type Module,
-  DocumentCache,
-  EmptyFileSystem,
-  inject,
-  WorkspaceCache,
-} from 'langium'
-import {
-  type DefaultSharedModuleContext,
-  type LangiumServices,
-  type LangiumSharedServices,
-  type PartialLangiumServices,
-  type PartialLangiumSharedServices,
-  createDefaultModule,
-  createDefaultSharedModule,
-} from 'langium/lsp'
-import { LikeC4DocumentationProvider } from './documentation'
-import { LikeC4Formatter } from './formatting/LikeC4Formatter'
-import {
-  LikeC4GeneratedModule,
-  LikeC4GeneratedSharedModule,
-} from './generated/module'
-import { logger, logToLspConnection } from './logger'
-import {
-  LikeC4CodeLensProvider,
-  LikeC4CompletionProvider,
-  LikeC4DocumentHighlightProvider,
-  LikeC4DocumentLinkProvider,
-  LikeC4DocumentSymbolProvider,
-  LikeC4HoverProvider,
-  LikeC4SemanticTokenProvider,
-} from './lsp'
-import {
-  DeploymentsIndex,
-  FqnIndex,
-  LikeC4ModelBuilder,
-  LikeC4ModelLocator,
-  LikeC4ModelParser,
-} from './model'
-import { LikeC4ModelChanges } from './model-change/ModelChanges'
-import {
-  LikeC4NameProvider,
-  LikeC4ScopeComputation,
-  LikeC4ScopeProvider,
-} from './references'
-import { Rpc } from './Rpc'
-import {
-  LikeC4WorkspaceManager,
-  NodeKindProvider,
-  WorkspaceSymbolProvider,
-} from './shared'
-import { registerValidationChecks } from './validation'
-import { LikeC4Views } from './views'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T
-
-interface LikeC4AddedSharedServices {
-  lsp: {
-    NodeKindProvider: NodeKindProvider
-    WorkspaceSymbolProvider: WorkspaceSymbolProvider
-  }
-  workspace: {
-    WorkspaceManager: LikeC4WorkspaceManager
-  }
-}
-
-export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices
-
-const LikeC4SharedModule: Module<
-  LikeC4SharedServices,
-  PartialLangiumSharedServices & LikeC4AddedSharedServices
-> = {
-  lsp: {
-    NodeKindProvider: services => new NodeKindProvider(services),
-    WorkspaceSymbolProvider: services => new WorkspaceSymbolProvider(services),
-  },
-  workspace: {
-    WorkspaceManager: services => new LikeC4WorkspaceManager(services),
-  },
-}
-
-/**
- * Declaration of custom services - add your own service classes here.
- */
-export interface LikeC4AddedServices {
-  documentation: {
-    DocumentationProvider: LikeC4DocumentationProvider
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  WorkspaceCache: WorkspaceCache<string, any>
-  DocumentCache: DocumentCache<string, any>
-  Rpc: Rpc
-  likec4: {
-    Views: LikeC4Views
-    Layouter: GraphvizLayouter
-    DeploymentsIndex: DeploymentsIndex
-    FqnIndex: FqnIndex
-    ModelParser: LikeC4ModelParser
-    ModelBuilder: LikeC4ModelBuilder
-    ModelLocator: LikeC4ModelLocator
-    ModelChanges: LikeC4ModelChanges
-  }
-  lsp: {
-    // RenameProvider: LikeC4RenameProvider
-    CompletionProvider: LikeC4CompletionProvider
-    DocumentHighlightProvider: LikeC4DocumentHighlightProvider
-    DocumentSymbolProvider: LikeC4DocumentSymbolProvider
-    SemanticTokenProvider: LikeC4SemanticTokenProvider
-    HoverProvider: LikeC4HoverProvider
-    CodeLensProvider: LikeC4CodeLensProvider
-    DocumentLinkProvider: LikeC4DocumentLinkProvider
-  }
-  references: {
-    NameProvider: LikeC4NameProvider
-    ScopeComputation: LikeC4ScopeComputation
-    ScopeProvider: LikeC4ScopeProvider
-  }
-  shared?: LikeC4SharedServices
-}
-
-export type LikeC4Services = LangiumServices & LikeC4AddedServices
-
-function bind<T>(Type: Constructor<T, [LikeC4Services]>) {
-  return (services: LikeC4Services) => new Type(services)
-}
-
-export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices> = {
-  documentation: {
-    DocumentationProvider: bind(LikeC4DocumentationProvider),
-  },
-  WorkspaceCache: (services: LikeC4Services) => new WorkspaceCache(services.shared),
-  DocumentCache: (services: LikeC4Services) => new DocumentCache(services.shared),
-  Rpc: bind(Rpc),
-  likec4: {
-    Layouter: (_services: LikeC4Services) => {
-      logger.debug('Creating GraphvizLayouter with GraphvizWasmAdapter')
-      return new GraphvizLayouter(new GraphvizWasmAdapter())
-    },
-    Views: bind(LikeC4Views),
-    DeploymentsIndex: bind(DeploymentsIndex),
-    ModelChanges: bind(LikeC4ModelChanges),
-    FqnIndex: bind(FqnIndex),
-    ModelParser: bind(LikeC4ModelParser),
-    ModelBuilder: bind(LikeC4ModelBuilder),
-    ModelLocator: bind(LikeC4ModelLocator),
-  },
-  lsp: {
-    // RenameProvider: bind(LikeC4RenameProvider),
-    CompletionProvider: bind(LikeC4CompletionProvider),
-    DocumentHighlightProvider: bind(LikeC4DocumentHighlightProvider),
-    DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
-    SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
-    HoverProvider: bind(LikeC4HoverProvider),
-    CodeLensProvider: bind(LikeC4CodeLensProvider),
-    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider),
-    Formatter: bind(LikeC4Formatter),
-  },
-  references: {
-    NameProvider: bind(LikeC4NameProvider),
-    ScopeComputation: bind(LikeC4ScopeComputation),
-    ScopeProvider: bind(LikeC4ScopeProvider),
-  },
-}
-
-export type LanguageServicesContext = Partial<DefaultSharedModuleContext>
-
-export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(
-  context: LanguageServicesContext,
-  module?: Module<I, I1>,
-  module2?: Module<I, I2>,
-  module3?: Module<I, I3>,
-): { shared: LikeC4SharedServices; likec4: I } {
-  const shared = createSharedServices(context)
-  const modules = [
-    createDefaultModule({ shared }),
-    LikeC4GeneratedModule,
-    LikeC4Module,
-    module,
-    module2,
-    module3,
-  ].reduce(_merge, {}) as Module<I>
-
-  const likec4 = inject(modules)
-  shared.ServiceRegistry.register(likec4)
-  registerValidationChecks(likec4)
-
-  if (!context.connection) {
-    // We don't run inside a language server
-    // Therefore, initialize the configuration provider instantly
-    shared.workspace.ConfigurationProvider.initialized({})
-  } else {
-    likec4.Rpc.init()
-  }
-
-  return { shared, likec4 }
-}
-
-export function createSharedServices(context: LanguageServicesContext = {}): LikeC4SharedServices {
-  const moduleContext: DefaultSharedModuleContext = {
-    ...EmptyFileSystem,
-    ...context,
-  }
-  if (context.connection) {
-    logToLspConnection(context.connection)
-  }
-
-  return inject(
-    createDefaultSharedModule(moduleContext),
-    LikeC4GeneratedSharedModule,
-    LikeC4SharedModule,
-  )
-}
-
-export function createLanguageServices(context: LanguageServicesContext = {}): {
-  shared: LikeC4SharedServices
-  likec4: LikeC4Services
-} {
-  const shared = createSharedServices(context)
-  const likec4 = inject(
-    createDefaultModule({ shared }),
-    LikeC4GeneratedModule,
-    LikeC4Module,
-  )
-  shared.ServiceRegistry.register(likec4)
-  registerValidationChecks(likec4)
-
-  if (!context.connection) {
-    // We don't run inside a language server
-    // Therefore, initialize the configuration provider instantly
-    shared.workspace.ConfigurationProvider.initialized({})
-  } else {
-    likec4.Rpc.init()
-  }
-
-  return { shared, likec4 }
-}
-
-// Copied from langium/src/dependency-injection.ts as it is not exported
-function _merge(target: Module<any>, source?: Module<any>): Module<unknown> {
-  if (source) {
-    for (const [key, value2] of Object.entries(source)) {
-      if (value2 !== undefined) {
-        const value1 = target[key]
-        if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {
-          target[key] = _merge(value1, value2)
-        } else {
-          target[key] = value2
-        }
-      }
-    }
-  }
-  return target
-}

package/src/protocol.ts

@@ -1,93 +0,0 @@
-import type {
-  ComputedLikeC4Model,
-  ComputedView,
-  DiagramView,
-  Fqn,
-  ParsedLikeC4Model,
-  RelationId,
-  ViewChange,
-  ViewId,
-} from '@likec4/core'
-import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc'
-import type { DocumentUri, Location } from 'vscode-languageserver-types'
-
-// #region From server
-export const onDidChangeModel = new NotificationType<string>('likec4/onDidChangeModel')
-export type OnDidChangeModelNotification = typeof onDidChangeModel
-// #endregion
-
-// #region To server
-
-export const fetchModel = new RequestType0<{ model: ParsedLikeC4Model | null }, void>(
-  'likec4/fetchModel',
-)
-export type FetchModelRequest = typeof fetchModel
-
-export const fetchComputedModel = new RequestType<
-  { cleanCaches?: boolean | undefined },
-  { model: ComputedLikeC4Model | null },
-  void
->(
-  'likec4/fetchComputedModel',
-)
-export type FetchComputedModelRequest = typeof fetchComputedModel
-
-export const computeView = new RequestType<{ viewId: ViewId }, { view: ComputedView | null }, void>(
-  'likec4/computeView',
-)
-export type ComputeViewRequest = typeof computeView
-
-/**
- * Request to layout a view.
- */
-export const layoutView = new RequestType<
-  { viewId: ViewId },
-  {
-    result:
-      | {
-        dot: string
-        diagram: DiagramView
-      }
-      | null
-  },
-  void
->('likec4/layout-view')
-export type LayoutViewRequest = typeof layoutView
-
-/**
- * Request to build documents.
- */
-export interface BuildDocumentsParams {
-  docs: DocumentUri[]
-}
-export const buildDocuments = new RequestType<BuildDocumentsParams, void, void>('likec4/build')
-export type BuildDocumentsRequest = typeof buildDocuments
-
-/**
- * Request to locate an element, relation, deployment or view.
- */
-export type LocateParams =
-  | {
-    element: Fqn
-    property?: string
-  }
-  | {
-    relation: RelationId
-  }
-  | {
-    deployment: Fqn
-    property?: string
-  }
-  | {
-    view: ViewId
-  }
-export const locate = new RequestType<LocateParams, Location | null, void>('likec4/locate')
-export type LocateRequest = typeof locate
-// #endregion
-
-export interface ChangeViewRequestParams {
-  viewId: ViewId
-  change: ViewChange
-}
-export const changeView = new RequestType<ChangeViewRequestParams, Location | null, void>('likec4/change-view')
-export type ChangeViewRequest = typeof changeView

package/src/references/index.ts

@@ -1,3 +0,0 @@
-export * from './name-provider'
-export * from './scope-computation'
-export * from './scope-provider'

package/src/references/name-provider.ts

@@ -1,37 +0,0 @@
-import { nonNullable } from '@likec4/core'
-import { type AstNode, type CstNode, DefaultNameProvider, isNamed, type NamedAstNode } from 'langium'
-import { ast } from '../ast'
-import type { LikeC4Services } from '../module'
-
-export class LikeC4NameProvider extends DefaultNameProvider {
-  constructor(protected services: LikeC4Services) {
-    super()
-  }
-
-  public getNameStrict(node: AstNode): string {
-    return nonNullable(
-      this.getName(node),
-      `Failed getName for ${this.services.workspace.AstNodeLocator.getAstNodePath(node)}`
-    )
-  }
-
-  override getName(node: AstNode): string | undefined {
-    if (isNamed(node)) {
-      return node.name
-    }
-    if (ast.isDeployedInstance(node)) {
-      return node.element.el.$refText
-    }
-    return undefined
-  }
-
-  override getNameNode(node: AstNode): CstNode | undefined {
-    if (isNamed(node)) {
-      return super.getNameNode(node)
-    }
-    if (ast.isDeployedInstance(node)) {
-      return node.element.el.$refNode
-    }
-    return undefined
-  }
-}