@likec4/language-server 1.42.1 → 1.44.0

package/dist/lsp/CompletionProvider.js

@@ -0,0 +1,200 @@
+import { ThemeColors } from '@likec4/core/styles';
+import { AstUtils } from 'langium';
+import { 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',
+    'textSize',
+].join(',');
+export class LikeC4CompletionProvider extends DefaultCompletionProvider {
+    services;
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    completionOptions = {
+        triggerCharacters: ['.', '#'],
+    };
+    completionForKeyword(context, keyword, acceptor) {
+        if (!this.filterKeyword(context, keyword)) {
+            return;
+        }
+        switch (true) {
+            case keyword.value === 'import':
+                acceptor(context, {
+                    label: keyword.value,
+                    kind: CompletionItemKind.Snippet,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: `${keyword.value} { $0 } from '\${1|${this.services.shared.workspace.ProjectsManager.all.join(',')}|}'`,
+                });
+                break;
+            case keyword.value === 'deployment' && AstUtils.hasContainerOfType(context.node, ast.isModelViews):
+                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'),
+                });
+                break;
+            case ['title', 'description', 'technology', 'link'].includes(keyword.value):
+                acceptor(context, {
+                    label: keyword.value,
+                    detail: `Insert ${keyword.value} property`,
+                    kind: CompletionItemKind.Property,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: `${keyword.value} '\${0}'`,
+                });
+                break;
+            case keyword.value === 'color':
+                acceptor(context, {
+                    label: keyword.value,
+                    kind: CompletionItemKind.Property,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: `${keyword.value} \${1|${ThemeColors.join(',')}|}$0`,
+                });
+                break;
+            case keyword.value === 'opacity':
+                acceptor(context, {
+                    label: keyword.value,
+                    kind: CompletionItemKind.Property,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: `${keyword.value} \${0:100}%`,
+                });
+                break;
+            case ['views', 'specification', 'model', 'deployment', 'with'].includes(keyword.value):
+                acceptor(context, {
+                    label: keyword.value,
+                    detail: `Insert ${keyword.value} block`,
+                    kind: CompletionItemKind.Module,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: `${keyword.value} {\n\t$0\n}`,
+                });
+                break;
+            case keyword.value === 'group':
+                acceptor(context, {
+                    label: keyword.value,
+                    detail: `Insert group block`,
+                    kind: CompletionItemKind.Module,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: [
+                        'group \'${1:Title}\' {',
+                        '\t$0',
+                        '}',
+                    ].join('\n'),
+                });
+                break;
+            case ['par', 'parallel'].includes(keyword.value):
+                acceptor(context, {
+                    label: keyword.value,
+                    detail: `Insert block of parallel steps`,
+                    kind: CompletionItemKind.Module,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: [
+                        `${keyword.value} {`,
+                        '\t$0',
+                        '}',
+                    ].join('\n'),
+                });
+                break;
+            case keyword.value === 'dynamic' && AstUtils.hasContainerOfType(context.node, ast.isModelViews):
+                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'),
+                });
+                break;
+            case keyword.value === 'style' && context.node && AstUtils.hasContainerOfType(context.node, ast.isGlobalStyle):
+                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}`,
+                });
+                break;
+            case keyword.value === 'style' && context.node &&
+                AstUtils.hasContainerOfType(context.node, anyPass([ast.isModelViews, ast.isGlobalStyleGroup])):
+                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}`,
+                });
+                break;
+            case keyword.value === 'style':
+                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}`,
+                });
+                break;
+            case keyword.value === 'extend':
+                acceptor(context, {
+                    label: keyword.value,
+                    detail: `Extend another view`,
+                    kind: CompletionItemKind.Class,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: 'extend $1 {\n\t$0\n}',
+                });
+                break;
+            case keyword.value === 'autoLayout':
+                acceptor(context, {
+                    label: keyword.value,
+                    kind: CompletionItemKind.Property,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: 'autoLayout ${1|TopBottom,BottomTop,LeftRight,RightLeft|}$0',
+                });
+                break;
+            case keyword.value === 'mode':
+                acceptor(context, {
+                    label: keyword.value,
+                    kind: CompletionItemKind.Property,
+                    insertTextFormat: InsertTextFormat.Snippet,
+                    insertText: 'mode ${1|sequence,diagram|}$0',
+                });
+                break;
+            case ['include', 'exclude'].includes(keyword.value):
+                acceptor(context, {
+                    label: keyword.value,
+                    kind: CompletionItemKind.Operator,
+                    detail: `Insert ${keyword.value} predicate`,
+                    insertTextFormat: InsertTextFormat.PlainText,
+                    insertText: `${keyword.value} `,
+                });
+                break;
+            default:
+                acceptor(context, {
+                    label: keyword.value,
+                    kind: this.getKeywordCompletionItemKind(keyword),
+                    detail: 'Keyword',
+                    sortText: '1',
+                });
+        }
+    }
+}

package/dist/lsp/DocumentHighlightProvider.js

@@ -0,0 +1,10 @@
+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.
+     */
+    createDocumentHighlight(reference) {
+        return DocumentHighlight.create(reference.segment.range, DocumentHighlightKind.Read);
+    }
+}

package/dist/lsp/DocumentLinkProvider.js

@@ -0,0 +1,58 @@
+import { AstUtils, GrammarUtils } from 'langium';
+import { hasLeadingSlash, hasProtocol, isRelative, joinRelativeURL, withoutBase, withoutLeadingSlash } from 'ufo';
+import { ast, isLikeC4LangiumDocument } from '../ast';
+import { logWarnError } from '../logger';
+export class LikeC4DocumentLinkProvider {
+    services;
+    constructor(services) {
+        this.services = services;
+        //
+    }
+    async getDocumentLinks(doc, _params, _cancelToken) {
+        if (!isLikeC4LangiumDocument(doc) || this.services.shared.workspace.ProjectsManager.isExcluded(doc)) {
+            return [];
+        }
+        return AstUtils.streamAllContents(doc.parseResult.value)
+            .filter(ast.isLinkProperty)
+            .map((n) => {
+            try {
+                const range = GrammarUtils.findNodeForProperty(n.$cstNode, 'value')?.range;
+                const target = range && this.resolveLink(doc, n.value);
+                if (target && hasProtocol(target)) {
+                    return {
+                        range,
+                        target,
+                    };
+                }
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+            return null;
+        })
+            .nonNullable()
+            .toArray();
+    }
+    resolveLink(doc, link) {
+        if (hasProtocol(link) || hasLeadingSlash(link)) {
+            return link;
+        }
+        if (isRelative(link)) {
+            return joinRelativeURL(doc.uri.toString(), '../', link);
+        }
+        const base = this.services.shared.workspace.ProjectsManager.getProject(doc).folderUri;
+        return joinRelativeURL(base.toString(), link);
+    }
+    relativeLink(doc, link) {
+        if (hasLeadingSlash(link)) {
+            return withoutLeadingSlash(link);
+        }
+        if (isRelative(link)) {
+            const base = this.services.shared.workspace.ProjectsManager.getProject(doc).folderUri.toString();
+            const docURL = new URL(doc.uri.toString());
+            const linkURL = new URL(link, docURL).toString();
+            return withoutLeadingSlash(withoutBase(linkURL, base));
+        }
+        return null;
+    }
+}

package/dist/lsp/DocumentSymbolProvider.js

@@ -0,0 +1,306 @@
+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 => 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.js

@@ -0,0 +1,106 @@
+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.js

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