@likec4/language-server 1.21.1 → 1.22.0

package/src/model/fqn-computation.ts

@@ -1,83 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { AsFqn, LinkedList, nonexhaustive } from '@likec4/core'
-import { type AstNodeDescription, type AstNodeLocator, AstUtils, CstUtils, GrammarUtils, MultiMap } from 'langium'
-import { isDefined, isEmpty } from 'remeda'
-import { type LikeC4LangiumDocument, ast, ElementOps } from '../ast'
-import { logError } from '../logger'
-import type { LikeC4Services } from '../module'
-import { getFqnElementRef } from '../utils/elementRef'
-
-const { findNodeForProperty } = GrammarUtils
-const { toDocumentSegment } = CstUtils
-const { getDocument } = AstUtils
-
-type TraversePair = [el: ast.Element | ast.ExtendElement | ast.Relation, parent: c4.Fqn | null]
-
-function toAstNodeDescription(
-  locator: AstNodeLocator,
-  entry: ast.Element,
-  doc: LikeC4LangiumDocument,
-): AstNodeDescription {
-  const $cstNode = findNodeForProperty(entry.$cstNode, 'name')
-  return {
-    documentUri: doc.uri,
-    name: entry.name,
-    ...(entry.$cstNode && {
-      selectionSegment: toDocumentSegment(entry.$cstNode),
-    }),
-    ...($cstNode && {
-      nameSegment: toDocumentSegment($cstNode),
-    }),
-    path: locator.getAstNodePath(entry),
-    type: ast.Element,
-  }
-}
-
-export function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services) {
-  const c4fqnIndex = (document.c4fqnIndex = new MultiMap())
-  const elements = document.parseResult.value.models.flatMap(m => m.elements)
-  if (elements.length === 0) {
-    return
-  }
-  const locator = services.workspace.AstNodeLocator
-  const traverseStack = LinkedList.from(elements.map(el => [el, null] as TraversePair))
-  let pair
-  while ((pair = traverseStack.shift())) {
-    try {
-      const [el, parent] = pair
-      if (ast.isRelation(el)) {
-        continue
-      }
-      if (ast.isExtendElement(el)) {
-        if (isDefined(el.body) && !isEmpty(el.body.elements)) {
-          const fqn = getFqnElementRef(el.element)
-          for (const child of el.body.elements) {
-            if (!ast.isRelation(child)) {
-              traverseStack.push([child, fqn])
-            }
-          }
-        }
-        continue
-      }
-      if (ast.isElement(el)) {
-        const fqn = AsFqn(el.name, parent)
-        c4fqnIndex.add(fqn, {
-          ...toAstNodeDescription(locator, el, document),
-          fqn,
-        })
-        ElementOps.writeId(el, fqn)
-        if (isDefined(el.body) && !isEmpty(el.body.elements)) {
-          for (const child of el.body.elements) {
-            if (!ast.isRelation(child)) {
-              traverseStack.push([child, fqn])
-            }
-          }
-        }
-        continue
-      }
-      nonexhaustive(el)
-    } catch (e) {
-      logError(e)
-    }
-  }
-}

package/src/model/fqn-index.ts

@@ -1,138 +0,0 @@
-import type { Fqn } from '@likec4/core'
-import { nameFromFqn, parentFqn } from '@likec4/core'
-import type { AstNodeDescription, LangiumDocuments, Stream } from 'langium'
-import { DocumentState, DONE_RESULT, MultiMap, stream, StreamImpl } from 'langium'
-import type { ast, DocFqnIndexAstNodeDescription, FqnIndexedDocument } from '../ast'
-import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from '../ast'
-import { logger, logWarnError } from '../logger'
-import type { LikeC4Services } from '../module'
-import { ADisposable } from '../utils'
-import { computeDocumentFqn } from './fqn-computation'
-
-export interface FqnIndexEntry {
-  fqn: Fqn
-  name: string
-  el: ast.Element
-  doc: FqnIndexedDocument
-  path: string
-}
-
-export class FqnIndex extends ADisposable {
-  protected langiumDocuments: LangiumDocuments
-
-  constructor(private services: LikeC4Services) {
-    super()
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments
-
-    this.onDispose(
-      services.shared.workspace.DocumentBuilder.onBuildPhase(
-        DocumentState.IndexedContent,
-        async (docs, _cancelToken) => {
-          for (const doc of docs) {
-            if (isLikeC4LangiumDocument(doc)) {
-              delete doc.c4fqnIndex
-              delete doc.c4Elements
-              delete doc.c4Specification
-              delete doc.c4Relations
-              delete doc.c4Deployments
-              delete doc.c4DeploymentRelations
-              delete doc.c4Globals
-              delete doc.c4Views
-              try {
-                computeDocumentFqn(doc, services)
-              } catch (e) {
-                logWarnError(e)
-              }
-            }
-          }
-          return await Promise.resolve()
-        },
-      ),
-    )
-    logger.debug(`[FqnIndex] Created`)
-  }
-
-  get documents() {
-    return this.langiumDocuments.all.filter(isFqnIndexedDocument)
-  }
-
-  private entries(filterByFqn: (fqn: Fqn) => boolean): Stream<DocFqnIndexAstNodeDescription> {
-    return this.documents.flatMap(doc => {
-      return doc.c4fqnIndex.keys().filter(filterByFqn).flatMap(fqn => doc.c4fqnIndex.get(fqn))
-    })
-  }
-
-  public getFqn(el: ast.Element): Fqn | null {
-    return ElementOps.readId(el) ?? null
-  }
-
-  public byFqn(fqn: Fqn): Stream<AstNodeDescription> {
-    return this.documents.flatMap(doc => {
-      return doc.c4fqnIndex.get(fqn)
-    })
-  }
-
-  public directChildrenOf(parent: Fqn): Stream<AstNodeDescription> {
-    return stream([parent]).flatMap(_parent => {
-      const children = this.entries(fqn => parentFqn(fqn) === _parent)
-        .map((entry) => [entry.name, entry] as [string, AstNodeDescription])
-        .toArray()
-      if (children.length === 0) {
-        return []
-      }
-      return new MultiMap(children)
-        .entriesGroupedByKey()
-        .flatMap(([_name, descrs]) => (descrs.length === 1 ? descrs : []))
-        .iterator()
-    })
-  }
-
-  /**
-   * Returns descedant elements with unique names in the scope
-   */
-  public uniqueDescedants(parent: Fqn): Stream<AstNodeDescription> {
-    return new StreamImpl(
-      () => {
-        const prefix = `${parent}.`
-
-        const childrenNames = new Set<string>()
-        const descedants = [] as AstNodeDescription[]
-
-        const nested = new MultiMap<string, AstNodeDescription>()
-
-        this.entries(f => f.startsWith(prefix)).forEach(e => {
-          const name = nameFromFqn(e.fqn)
-          const entry = { ...e, name }
-          // To keep direct children always
-          if (parentFqn(e.fqn) === parent) {
-            childrenNames.add(name)
-            nested.add(name, entry)
-          } else {
-            descedants.push(entry)
-          }
-        })
-
-        if (nested.size + descedants.length === 0) {
-          return null
-        }
-
-        for (const descedant of descedants) {
-          if (!childrenNames.has(descedant.name)) {
-            nested.add(descedant.name, descedant)
-          }
-        }
-
-        return nested
-          .entriesGroupedByKey()
-          .flatMap(([_name, descrs]) => (descrs.length === 1 ? descrs : []))
-          .iterator()
-      },
-      iterator => {
-        if (iterator) {
-          return iterator.next()
-        }
-        return DONE_RESULT as IteratorResult<AstNodeDescription>
-      },
-    )
-  }
-}

package/src/model/index.ts

@@ -1,6 +0,0 @@
-export * from './deployments-index'
-export * from './fqn-computation'
-export * from './fqn-index'
-export * from './model-builder'
-export * from './model-locator'
-export * from './model-parser'