@likec4/language-server 1.2.0 → 1.2.1

package/dist/lsp/DocumentSymbolProvider.js

@@ -1,189 +0,0 @@
-import { nonexhaustive } from "@likec4/core";
-import { GrammarUtils } from "langium";
-import { filter, isEmpty, isTruthy, map, pipe } from "remeda";
-import { SymbolKind } from "vscode-languageserver-protocol";
-import { ast } from "../ast.js";
-import { getFqnElementRef } from "../elementRef.js";
-import { logError } from "../logger.js";
-export class LikeC4DocumentSymbolProvider {
-  constructor(services) {
-    this.services = services;
-    this.nodeKindProvider = services.shared.lsp.NodeKindProvider;
-  }
-  nodeKindProvider;
-  getSymbols({
-    parseResult: {
-      value: { specifications, models, views }
-    }
-  }) {
-    return [
-      ...specifications.map((s) => () => this.getSpecSymbol(s)),
-      ...models.map((s) => () => this.getModelSymbol(s)),
-      ...views.map((s) => () => this.getModelViewsSymbol(s))
-    ].flatMap((fn) => {
-      try {
-        return fn() ?? [];
-      } catch (e) {
-        logError(e);
-        return [];
-      }
-    });
-  }
-  getSpecSymbol(astSpec) {
-    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)) {
-            return this.getKindSymbol(nd);
-          }
-          if (ast.isSpecificationTag(nd)) {
-            return this.getTagSymbol(nd);
-          }
-        } catch (e) {
-          logError(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
-      }
-    ];
-  }
-  getModelSymbol(astModel) {
-    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))
-      }
-    ];
-  }
-  getElementsSymbol(el) {
-    try {
-      if (ast.isExtendElement(el)) {
-        return this.getExtendElementSymbol(el);
-      }
-      if (ast.isElement(el)) {
-        return this.getElementSymbol(el);
-      }
-    } catch (e) {
-      logError(e);
-    }
-    return [];
-  }
-  getExtendElementSymbol(astElement) {
-    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))
-      }
-    ];
-  }
-  getElementSymbol(astElement) {
-    const cst = astElement.$cstNode;
-    const nameNode = GrammarUtils.findNodeForProperty(cst, "name");
-    if (!nameNode || !cst)
-      return [];
-    const name = astElement.name;
-    const kind = astElement.kind.$refText;
-    const detail = kind;
-    return [
-      {
-        kind: this.symbolKind(astElement),
-        name,
-        range: cst.range,
-        selectionRange: nameNode.range,
-        detail,
-        children: astElement.body?.elements.flatMap((e) => this.getElementsSymbol(e)) ?? []
-      }
-    ];
-  }
-  getModelViewsSymbol(astViews) {
-    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))
-      }
-    ];
-  }
-  getKindSymbol(astKind) {
-    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
-    };
-  }
-  getTagSymbol(astTag) {
-    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
-    };
-  }
-  getViewSymbol(astView) {
-    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: []
-      }
-    ];
-  }
-  symbolKind(node) {
-    return this.nodeKindProvider.getSymbolKind(node);
-  }
-}

package/dist/lsp/HoverProvider.d.ts

@@ -1,10 +0,0 @@
-import { type AstNode, type MaybePromise } from 'langium';
-import { AstNodeHoverProvider } from 'langium/lsp';
-import type { Hover } from 'vscode-languageserver-protocol';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4HoverProvider extends AstNodeHoverProvider {
-    private locator;
-    constructor(services: LikeC4Services);
-    protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
-}
-//# sourceMappingURL=HoverProvider.d.ts.map

package/dist/lsp/HoverProvider.js

@@ -1,36 +0,0 @@
-import { AstNodeHoverProvider } from "langium/lsp";
-import stripIndent from "strip-indent";
-import { ast } from "../ast.js";
-export class LikeC4HoverProvider extends AstNodeHoverProvider {
-  locator;
-  constructor(services) {
-    super(services);
-    this.locator = services.likec4.ModelLocator;
-  }
-  getAstNodeHoverContent(node) {
-    if (ast.isTag(node)) {
-      return {
-        contents: {
-          kind: "markdown",
-          value: stripIndent(`
-            tag: \`${node.name}\`
-          `)
-        }
-      };
-    }
-    if (ast.isElement(node)) {
-      const el = this.locator.getParsedElement(node);
-      if (!el) {
-        return;
-      }
-      const lines = [el.id, `### ${el.title}`, "`" + el.kind + "` "];
-      return {
-        contents: {
-          kind: "markdown",
-          value: lines.join("\n")
-        }
-      };
-    }
-    return;
-  }
-}

package/dist/lsp/SemanticTokenProvider.d.ts

@@ -1,8 +0,0 @@
-import type { AstNode } from 'langium';
-import { AbstractSemanticTokenProvider, type SemanticTokenAcceptor } from 'langium/lsp';
-export declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
-    protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
-    private highlightAstElement;
-    private highlightView;
-}
-//# sourceMappingURL=SemanticTokenProvider.d.ts.map

package/dist/lsp/index.d.ts

@@ -1,7 +0,0 @@
-export * from './CodeLensProvider';
-export * from './DocumentHighlightProvider';
-export * from './DocumentLinkProvider';
-export * from './DocumentSymbolProvider';
-export * from './HoverProvider';
-export * from './SemanticTokenProvider';
-//# sourceMappingURL=index.d.ts.map

package/dist/lsp/index.js

@@ -1,6 +0,0 @@
-export * from "./CodeLensProvider.js";
-export * from "./DocumentHighlightProvider.js";
-export * from "./DocumentLinkProvider.js";
-export * from "./DocumentSymbolProvider.js";
-export * from "./HoverProvider.js";
-export * from "./SemanticTokenProvider.js";

package/dist/model/fqn-computation.d.ts

@@ -1,4 +0,0 @@
-import { type LikeC4LangiumDocument } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services): void;
-//# sourceMappingURL=fqn-computation.d.ts.map

package/dist/model/fqn-computation.js

@@ -1,43 +0,0 @@
-import { AsFqn, nonexhaustive } from "@likec4/core";
-import { MultiMap } from "langium";
-import { isEmpty, isNullish as isNil } from "remeda";
-import { ast, ElementOps } from "../ast.js";
-import { getFqnElementRef } from "../elementRef.js";
-export function computeDocumentFqn(document, services) {
-  const c4fqns = document.c4fqns = new MultiMap();
-  const elements = document.parseResult.value.models.flatMap((m) => m.elements);
-  if (elements.length === 0) {
-    return;
-  }
-  const locator = services.workspace.AstNodeLocator;
-  const traverseStack = elements.map((el) => [el, null]);
-  let pair;
-  while (pair = traverseStack.shift()) {
-    const [el, parent] = pair;
-    if (ast.isRelation(el)) {
-      continue;
-    }
-    if (ast.isExtendElement(el)) {
-      if (!isNil(el.body) && !isEmpty(el.body.elements)) {
-        const fqn = getFqnElementRef(el.element);
-        el.body.elements.forEach((child) => traverseStack.push([child, fqn]));
-      }
-      continue;
-    }
-    if (ast.isElement(el)) {
-      const fqn = AsFqn(el.name, parent);
-      const path = locator.getAstNodePath(el);
-      c4fqns.add(fqn, {
-        el: new WeakRef(el),
-        path,
-        name: el.name
-      });
-      ElementOps.writeId(el, fqn);
-      if (!isNil(el.body) && !isEmpty(el.body.elements)) {
-        el.body.elements.forEach((child) => traverseStack.push([child, fqn]));
-      }
-      continue;
-    }
-    nonexhaustive(el);
-  }
-}

package/dist/model/fqn-index.d.ts

@@ -1,26 +0,0 @@
-import type { Fqn } from '@likec4/core';
-import type { LangiumDocuments, Stream } from 'langium';
-import type { ast, FqnIndexedDocument } from '../ast';
-import type { LikeC4Services } from '../module';
-export interface FqnIndexEntry {
-    fqn: Fqn;
-    name: string;
-    el: ast.Element;
-    doc: FqnIndexedDocument;
-    path: string;
-}
-export declare class FqnIndex {
-    private services;
-    protected langiumDocuments: LangiumDocuments;
-    constructor(services: LikeC4Services);
-    get documents(): Stream<FqnIndexedDocument>;
-    private entries;
-    getFqn(el: ast.Element): Fqn | null;
-    byFqn(fqn: Fqn): Stream<FqnIndexEntry>;
-    directChildrenOf(parent: Fqn): Stream<FqnIndexEntry>;
-    /**
-     * Returns descedant elements with unique names in the scope
-     */
-    uniqueDescedants(parent: Fqn): Stream<FqnIndexEntry>;
-}
-//# sourceMappingURL=fqn-index.d.ts.map

package/dist/model/fqn-index.js

@@ -1,114 +0,0 @@
-import { nameFromFqn, parentFqn } from "@likec4/core";
-import { DocumentState, DONE_RESULT, MultiMap, stream, StreamImpl } from "langium";
-import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from "../ast.js";
-import { logError, logger } from "../logger.js";
-import { printDocs } from "../utils/printDocs.js";
-import { computeDocumentFqn } from "./fqn-computation.js";
-const True = () => true;
-export class FqnIndex {
-  constructor(services) {
-    this.services = services;
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-    services.shared.workspace.DocumentBuilder.onBuildPhase(
-      DocumentState.IndexedContent,
-      async (docs, _cancelToken) => {
-        logger.debug(`[FqnIndex] onIndexedContent ${docs.length}:
-` + printDocs(docs));
-        for (const doc of docs) {
-          if (isLikeC4LangiumDocument(doc)) {
-            delete doc.c4fqns;
-            delete doc.c4Elements;
-            delete doc.c4Specification;
-            delete doc.c4Relations;
-            delete doc.c4Views;
-            try {
-              computeDocumentFqn(doc, services);
-            } catch (e) {
-              logError(e);
-            }
-          }
-        }
-        return Promise.resolve();
-      }
-    );
-    logger.debug(`[FqnIndex] Created`);
-  }
-  langiumDocuments;
-  get documents() {
-    return this.langiumDocuments.all.filter(isFqnIndexedDocument);
-  }
-  entries(filterByFqn = True) {
-    return this.documents.flatMap(
-      (doc) => doc.c4fqns.entries().flatMap(([fqn, entry]) => {
-        if (filterByFqn(fqn)) {
-          const el = entry.el.deref();
-          if (el) {
-            return { ...entry, fqn, el, doc };
-          }
-        }
-        return [];
-      })
-    );
-  }
-  getFqn(el) {
-    return ElementOps.readId(el) ?? null;
-  }
-  byFqn(fqn) {
-    return this.documents.flatMap((doc) => {
-      return doc.c4fqns.get(fqn).flatMap((entry) => {
-        const el = entry.el.deref();
-        if (el) {
-          return { fqn, el, doc, path: entry.path, name: entry.name };
-        }
-        return [];
-      });
-    });
-  }
-  directChildrenOf(parent) {
-    return stream([parent]).flatMap((_parent) => {
-      const children = this.entries((fqn) => parentFqn(fqn) === _parent).map((entry) => [entry.name, entry]).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
-   */
-  uniqueDescedants(parent) {
-    return new StreamImpl(
-      () => {
-        const prefix = `${parent}.`;
-        const childrenNames = /* @__PURE__ */ new Set();
-        const descedants = [];
-        const nested = new MultiMap();
-        this.entries((f) => f.startsWith(prefix)).forEach((e) => {
-          const name = nameFromFqn(e.fqn);
-          const entry = { ...e, name };
-          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;
-      }
-    );
-  }
-}

package/dist/model/index.d.ts

@@ -1,6 +0,0 @@
-export * from './fqn-computation';
-export * from './fqn-index';
-export * from './model-builder';
-export * from './model-locator';
-export * from './model-parser';
-//# sourceMappingURL=index.d.ts.map

package/dist/model/index.js

@@ -1,5 +0,0 @@
-export * from "./fqn-computation.js";
-export * from "./fqn-index.js";
-export * from "./model-builder.js";
-export * from "./model-locator.js";
-export * from "./model-parser.js";

package/dist/model/model-builder.d.ts

@@ -1,20 +0,0 @@
-import { type c4, type ViewID } from '@likec4/core';
-import type { URI } from 'langium';
-import { type CancellationToken, Disposable } from 'vscode-languageserver';
-import type { LikeC4Services } from '../module';
-type ModelParsedListener = (docs: URI[]) => void;
-export declare class LikeC4ModelBuilder {
-    private services;
-    private langiumDocuments;
-    private listeners;
-    constructor(services: LikeC4Services);
-    buildModel(cancelToken?: CancellationToken): Promise<c4.LikeC4Model | null>;
-    private previousViews;
-    buildComputedModel(cancelToken?: CancellationToken): Promise<c4.LikeC4ComputedModel | null>;
-    computeView(viewId: ViewID, cancelToken?: CancellationToken): Promise<c4.ComputedView | null>;
-    onModelParsed(callback: ModelParsedListener): Disposable;
-    private documents;
-    private notifyListeners;
-}
-export {};
-//# sourceMappingURL=model-builder.d.ts.map