@likec4/language-server 1.46.4 → 1.48.0

package/dist/lsp/DocumentSymbolProvider.js

@@ -1,317 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Copyright (c) 2023-2025 Denis Davydkov
-// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-//
-// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
-import { nonexhaustive } from '@likec4/core';
-import { AstUtils, DocumentState, GrammarUtils } from 'langium';
-import { filter, isEmpty, isTruthy, map, pipe } from 'remeda';
-import { SymbolKind } from 'vscode-languageserver-types';
-import { ast, isLikeC4LangiumDocument } from '../ast';
-import { logger as rootLogger, logWarnError } from '../logger';
-import { readStrictFqn } from '../utils/elementRef';
-const logger = rootLogger.getChild('DocumentSymbolProvider');
-export class LikeC4DocumentSymbolProvider {
-    services;
-    nodeKindProvider;
-    nameProvider;
-    parser;
-    locator;
-    constructor(services) {
-        this.services = services;
-        this.nodeKindProvider = services.shared.lsp.NodeKindProvider;
-        this.parser = services.likec4.ModelParser;
-        this.locator = services.likec4.ModelLocator;
-        this.nameProvider = services.references.NameProvider;
-    }
-    async getSymbols(doc, _params, cancelToken) {
-        if (!isLikeC4LangiumDocument(doc) || this.services.shared.workspace.ProjectsManager.isExcluded(doc)) {
-            return [];
-        }
-        if (doc.state <= DocumentState.Linked) {
-            logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
-            await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
-            logger.debug(`document is Linked`);
-        }
-        const { parseResult: { value: { specifications, models, deployments, views, likec4lib }, }, } = doc;
-        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 [];
-            }
-        });
-    }
-    getLikec4LibSymbol(astLib) {
-        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,
-            },
-        ];
-    }
-    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)
-                    || 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,
-            },
-        ];
-    }
-    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 => {
-                    // Skip ExtendRelation nodes as they don't need symbols
-                    if (ast.isExtendRelation(e))
-                        return [];
-                    return this.getElementsSymbol(e);
-                }),
-            },
-        ];
-    }
-    getDeploymentModelSymbol(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.getDeploymentElementSymbol(e)),
-            },
-        ];
-    }
-    getElementsSymbol(el) {
-        try {
-            if (ast.isExtendElement(el)) {
-                return this.getExtendElementSymbol(el);
-            }
-            if (ast.isElement(el)) {
-                return this.getElementSymbol(el);
-            }
-        }
-        catch (e) {
-            logWarnError(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: readStrictFqn(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;
-        // 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)) ?? [],
-            },
-        ];
-    }
-    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,
-        };
-    }
-    getLibIconSymbol(astTag) {
-        if (!astTag.$cstNode || isEmpty(astTag.name))
-            return null;
-        return {
-            kind: this.symbolKind(astTag),
-            name: astTag.name,
-            range: astTag.$cstNode.range,
-            selectionRange: astTag.$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: [],
-            },
-        ];
-    }
-    getDeploymentElementSymbol(el) {
-        try {
-            if (ast.isDeploymentNode(el)) {
-                return this.getDeploymentNodeSymbol(el);
-            }
-            if (ast.isDeployedInstance(el)) {
-                return this.getDeployedInstanceSymbol(el);
-            }
-            if (ast.isExtendDeployment(el)) {
-                return [];
-            }
-        }
-        catch (e) {
-            logWarnError(e);
-        }
-        return [];
-    }
-    getDeploymentNodeSymbol(astElement) {
-        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)) ?? [],
-            },
-        ];
-    }
-    getDeployedInstanceSymbol(astElement) {
-        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.model;
-        return [
-            {
-                kind: this.symbolKind(astElement),
-                name: name,
-                range: cst.range,
-                selectionRange: nameNode.range,
-                detail,
-                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-types';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4HoverProvider extends AstNodeHoverProvider {
-    private parser;
-    private locator;
-    constructor(services: LikeC4Services);
-    protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
-}

package/dist/lsp/HoverProvider.js

@@ -1,106 +0,0 @@
-import { FqnRef, preferSummary } from '@likec4/core';
-import { AstUtils } from 'langium';
-import { AstNodeHoverProvider } from 'langium/lsp';
-import { ast } from '../ast';
-export class LikeC4HoverProvider extends AstNodeHoverProvider {
-    parser;
-    locator;
-    constructor(services) {
-        super(services);
-        this.parser = services.likec4.ModelParser;
-        this.locator = services.likec4.ModelLocator;
-    }
-    getAstNodeHoverContent(node) {
-        if (ast.isTag(node)) {
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: 'tag `' + node.name + '`',
-                },
-            };
-        }
-        if (ast.isDeploymentNode(node)) {
-            const doc = AstUtils.getDocument(node);
-            const el = this.parser.forDocument(doc).parseDeploymentNode(node);
-            const lines = [el.id + '  '];
-            if (el.title !== node.name) {
-                lines.push(`### ${el.title}`);
-            }
-            lines.push('deployment node `' + el.kind + '` ');
-            const summary = preferSummary(el);
-            if (summary) {
-                lines.push('', summary.md ?? summary.txt);
-            }
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: lines.join('\n'),
-                },
-            };
-        }
-        if (ast.isDeployedInstance(node)) {
-            const doc = AstUtils.getDocument(node);
-            const instance = this.parser.forDocument(doc).parseDeployedInstance(node);
-            const [projectId, fqn] = FqnRef.isImportRef(instance.element)
-                ? [instance.element.project, instance.element.model]
-                : [doc.likec4ProjectId, instance.element.model];
-            const el = projectId ? this.locator.getParsedElement(fqn, projectId) : this.locator.getParsedElement(fqn);
-            const lines = [instance.id + '  ', `instance of \`${FqnRef.flatten(instance.element)}\``];
-            if (el) {
-                lines.push(`### ${el.title}`, 'element kind `' + el.kind + '` ');
-            }
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: lines.join('\n'),
-                },
-            };
-        }
-        if (ast.isElementKind(node)) {
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: 'element kind `' + node.name + '`',
-                },
-            };
-        }
-        if (ast.isDeploymentNodeKind(node)) {
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: 'deployment node `' + node.name + '`',
-                },
-            };
-        }
-        if (ast.isRelationshipKind(node)) {
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: 'relationship kind `' + node.name + '`',
-                },
-            };
-        }
-        if (ast.isElement(node)) {
-            const el = this.locator.getParsedElement(node);
-            if (!el) {
-                return;
-            }
-            const lines = [
-                el.id,
-                `### ${el.title}`,
-                'element kind `' + el.kind + '` ',
-            ];
-            const summary = preferSummary(el);
-            if (summary) {
-                lines.push('', summary.md ?? summary.txt);
-            }
-            return {
-                contents: {
-                    kind: 'markdown',
-                    value: lines.join('\n'),
-                },
-            };
-        }
-        return;
-    }
-}

package/dist/lsp/RenameProvider.d.ts

@@ -1,5 +0,0 @@
-import { DefaultRenameProvider } from 'langium/lsp';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4RenameProvider extends DefaultRenameProvider {
-    constructor(services: LikeC4Services);
-}

package/dist/lsp/RenameProvider.js

@@ -1,6 +0,0 @@
-import { DefaultRenameProvider } from 'langium/lsp';
-export class LikeC4RenameProvider extends DefaultRenameProvider {
-    constructor(services) {
-        super(services);
-    }
-}

package/dist/lsp/SemanticTokenProvider.d.ts

@@ -1,12 +0,0 @@
-import type { AstNode } from 'langium';
-import { type SemanticTokenAcceptor, AbstractSemanticTokenProvider } from 'langium/lsp';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
-    private rules;
-    constructor(services: LikeC4Services);
-    protected initRules(): void;
-    protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
-    private highlightNameAndKind;
-    private highlightView;
-    private mark;
-}