@likec4/language-server 0.2.0

package/dist/generated/module.d.ts

@@ -0,0 +1,9 @@
+/******************************************************************************
+ * This file was generated by langium-cli 1.1.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+import { LangiumGeneratedServices, LangiumGeneratedSharedServices, LangiumSharedServices, LangiumServices, LanguageMetaData, Module, IParserConfig } from 'langium';
+export declare const LikeC4LanguageMetaData: LanguageMetaData;
+export declare const parserConfig: IParserConfig;
+export declare const LikeC4GeneratedSharedModule: Module<LangiumSharedServices, LangiumGeneratedSharedServices>;
+export declare const LikeC4GeneratedModule: Module<LangiumServices, LangiumGeneratedServices>;

package/dist/generated/module.js

@@ -0,0 +1,26 @@
+/******************************************************************************
+ * This file was generated by langium-cli 1.1.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+import 'langium';
+import { LikeC4AstReflection } from './ast';
+import { LikeC4Grammar } from './grammar';
+export const LikeC4LanguageMetaData = {
+    languageId: 'likec4',
+    fileExtensions: ['.c4', '.likec4', '.like-c4'],
+    caseInsensitive: false
+};
+export const parserConfig = {
+    recoveryEnabled: true,
+    nodeLocationTracking: 'full',
+};
+export const LikeC4GeneratedSharedModule = {
+    AstReflection: () => new LikeC4AstReflection()
+};
+export const LikeC4GeneratedModule = {
+    Grammar: () => LikeC4Grammar(),
+    LanguageMetaData: () => LikeC4LanguageMetaData,
+    parser: {
+        ParserConfig: () => parserConfig
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createLanguageServices } from './module';
+export { LikeC4LanguageMetaData as LanguageMetaData } from './generated/module';
+export { Rpc } from './protocol';

package/dist/index.js

@@ -0,0 +1,16 @@
+// import { type DefaultSharedModuleContext, startLanguageServer as startLangiumLanguageServer } from 'langium'
+export { createLanguageServices } from './module';
+// export type { C4XServices }
+// export type { C4XModel } from './c4x-model'
+// export type { C4XLangiumDocument } from './ast'
+// export {
+//   LanguageId
+// } from './const'
+export { LikeC4LanguageMetaData as LanguageMetaData } from './generated/module';
+// export { createC4XServices }
+// export function startLanguageServices(context: DefaultSharedModuleContext) {
+//   const { shared, likec4 } = createLikeC4Services(context)
+//   startLangiumLanguageServer(shared)
+//   return likec4
+// }
+export { Rpc } from './protocol';

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+export declare const logger: {
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string | Error | unknown): void;
+    log(message: string): void;
+    error(message: string | Error | unknown): void;
+    trace(message: string): void;
+};

package/dist/logger.js

@@ -0,0 +1,20 @@
+export const logger = {
+    debug(message) {
+        console.debug(message);
+    },
+    info(message) {
+        console.info(message);
+    },
+    warn(message) {
+        console.warn(message);
+    },
+    log(message) {
+        console.log(message);
+    },
+    error(message) {
+        console.error(message);
+    },
+    trace(message) {
+        console.debug(message);
+    }
+};

package/dist/lsp/CodeLensProvider.d.ts

@@ -0,0 +1,8 @@
+import type { LangiumDocument, LangiumSharedServices, MaybePromise } from 'langium';
+import type { CodeLensProvider } from 'langium/lib/lsp/code-lens-provider';
+import type { CancellationToken, CodeLens, CodeLensParams } from 'vscode-languageserver-protocol';
+export declare class LikeC4CodeLensProvider implements CodeLensProvider {
+    private services;
+    constructor(services: LangiumSharedServices);
+    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, _cancelToken?: CancellationToken): MaybePromise<CodeLens[] | undefined>;
+}

package/dist/lsp/CodeLensProvider.js

@@ -0,0 +1,35 @@
+import { ElementViewOps, isParsedLikeC4LangiumDocument } from '../ast';
+export class LikeC4CodeLensProvider {
+    services;
+    constructor(services) {
+        this.services = services;
+        //
+    }
+    provideCodeLens(doc, _params, _cancelToken) {
+        if (!isParsedLikeC4LangiumDocument(doc)) {
+            return;
+        }
+        return doc.parseResult.value.views?.views.flatMap((ast) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const viewId = ElementViewOps.readId(ast);
+            const range = ast.$cstNode?.range;
+            if (!range || !viewId) {
+                return [];
+            }
+            return {
+                range: {
+                    start: range.start,
+                    end: {
+                        line: range.start.line,
+                        character: range.start.character + 4
+                    }
+                },
+                command: {
+                    command: 'likec4.open-preview',
+                    arguments: [viewId],
+                    title: 'open preview',
+                }
+            };
+        });
+    }
+}

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -0,0 +1,21 @@
+/******************************************************************************
+ * Copyright 2021 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+/// <reference types="react" />
+import { type DocumentSymbolProvider, type MaybePromise } from 'langium';
+import { type DocumentSymbol } from 'vscode-languageserver-protocol';
+import { type LikeC4LangiumDocument, ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    getSymbols(document: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]>;
+    protected getSpecSymbols: (astSpec: ast.SpecificationRule | undefined) => DocumentSymbol[];
+    protected getModelSymbols: (astModel: ast.Model | undefined) => DocumentSymbol[];
+    protected getElementsSymbol: (el: ast.Element | ast.Relation | ast.ExtendElement) => DocumentSymbol[];
+    protected getExtendElementSymbol: (astElement: ast.ExtendElement) => DocumentSymbol[];
+    protected getElementSymbol: (astElement: ast.Element) => DocumentSymbol[];
+    protected getModelViewsSymbols: (astViews: ast.ModelViews | undefined) => DocumentSymbol[];
+}

package/dist/lsp/DocumentSymbolProvider.js

@@ -0,0 +1,138 @@
+/******************************************************************************
+ * Copyright 2021 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+import invariant from 'tiny-invariant';
+import { findNodeForProperty } from 'langium';
+import { SymbolKind } from 'vscode-languageserver-protocol';
+import { ast } from '../ast';
+export class LikeC4DocumentSymbolProvider {
+    services;
+    constructor(services) {
+        this.services = services;
+    }
+    getSymbols(document) {
+        const { specification, model, views } = document.parseResult.value;
+        return [
+            ...this.getSpecSymbols(specification),
+            ...this.getModelSymbols(model),
+            ...this.getModelViewsSymbols(views)
+        ];
+    }
+    getSpecSymbols = (astSpec) => {
+        const cstModel = astSpec?.$cstNode;
+        if (!cstModel)
+            return [];
+        const specKeywordNode = findNodeForProperty(cstModel, 'name');
+        if (!specKeywordNode)
+            return [];
+        const specSymbols = [];
+        const getElementKindSymbol = (astKind) => {
+            invariant(astKind.$cstNode, 'SpecificationElementKind must have a CST node');
+            invariant(astKind.kind.$cstNode, 'SpecificationElementKind name must have a CST node');
+            return {
+                kind: SymbolKind.Class,
+                name: astKind.kind.name,
+                range: astKind.$cstNode.range,
+                selectionRange: astKind.kind.$cstNode.range
+            };
+        };
+        for (const astKind of astSpec.elementKinds) {
+            specSymbols.push(getElementKindSymbol(astKind));
+        }
+        const getTagSymbol = (astTag) => {
+            invariant(astTag.$cstNode, 'TagSpec must have a CST node');
+            invariant(astTag.tag.$cstNode, 'Tag name must have a CST node');
+            return {
+                kind: SymbolKind.EnumMember,
+                name: '#' + astTag.tag.name,
+                range: astTag.$cstNode.range,
+                selectionRange: astTag.tag.$cstNode.range
+            };
+        };
+        for (const astTag of astSpec.tags) {
+            specSymbols.push(getTagSymbol(astTag));
+        }
+        if (specSymbols.length === 0)
+            return [];
+        return [{
+                kind: SymbolKind.Class,
+                name: astSpec.name,
+                range: cstModel.range,
+                selectionRange: specKeywordNode.range,
+                children: specSymbols
+            }];
+    };
+    getModelSymbols = (astModel) => {
+        const cstModel = astModel?.$cstNode;
+        if (!cstModel)
+            return [];
+        const nameNode = findNodeForProperty(cstModel, 'name');
+        if (!nameNode)
+            return [];
+        return [{
+                kind: SymbolKind.Class,
+                name: astModel.name,
+                range: cstModel.range,
+                selectionRange: nameNode.range,
+                children: astModel.elements.flatMap(this.getElementsSymbol)
+            }];
+    };
+    getElementsSymbol = (el) => {
+        if (ast.isExtendElement(el)) {
+            return this.getExtendElementSymbol(el);
+        }
+        if (ast.isElement(el)) {
+            return this.getElementSymbol(el);
+        }
+        return [];
+    };
+    getExtendElementSymbol = (astElement) => {
+        const cst = astElement.$cstNode;
+        const nameNode = astElement.element.$cstNode;
+        if (!cst || !nameNode)
+            return [];
+        return [{
+                kind: SymbolKind.Constructor,
+                name: nameNode.text,
+                range: cst.range,
+                selectionRange: nameNode.range,
+                children: astElement.body.elements.flatMap(this.getElementsSymbol)
+            }];
+    };
+    getElementSymbol = (astElement) => {
+        const cst = astElement.$cstNode;
+        if (!cst)
+            return [];
+        const nameNode = findNodeForProperty(cst, 'name');
+        if (!nameNode)
+            return [];
+        const name = astElement.name;
+        const kind = astElement.kind.$refText;
+        const detail = kind + (astElement.title ? ': ' + astElement.title : '').replaceAll('\n', ' ').trim();
+        return [{
+                kind: SymbolKind.Constructor,
+                name: name,
+                range: cst.range,
+                selectionRange: nameNode.range,
+                detail,
+                children: astElement.body?.elements.flatMap(this.getElementsSymbol) ?? []
+            }];
+    };
+    getModelViewsSymbols = (astViews) => {
+        const cst = astViews?.$cstNode;
+        if (!cst)
+            return [];
+        const nameNode = findNodeForProperty(cst, 'name');
+        if (!nameNode)
+            return [];
+        return [{
+                kind: SymbolKind.Class,
+                name: astViews.name,
+                range: cst.range,
+                selectionRange: nameNode.range,
+                children: []
+            }];
+    };
+}

package/dist/lsp/HoverProvider.d.ts

@@ -0,0 +1,8 @@
+import { type AstNode, AstNodeHoverProvider, type MaybePromise } from 'langium';
+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>;
+}

package/dist/lsp/HoverProvider.js

@@ -0,0 +1,57 @@
+import { AstNodeHoverProvider } from 'langium';
+import stripIndent from 'strip-indent';
+import { ast } from '../ast';
+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.isElementKind(node)) {
+        //   const spec = this.specIndex.get(node.name as ElementKind)
+        //   return {
+        //     contents: {
+        //       kind: 'markdown',
+        //       value: stripIndent(`
+        //         kind: **${spec.id}**
+        //         shape: ${spec.style.shape}
+        //       `)
+        //     }
+        //   }
+        // }
+        if (ast.isElement(node)) {
+            const el = this.locator.getParsedElement(node);
+            if (!el) {
+                return;
+            }
+            const lines = [
+                el.id,
+                `${el.kind}: **${el.title}**`
+            ];
+            if (el.tags && el.tags.length > 0) {
+                lines.push('  \n', el.tags.map(t => '#' + t).join(', '));
+            }
+            if (el.description) {
+                lines.push('  \n', el.description);
+            }
+            return {
+                contents: {
+                    kind: 'markdown',
+                    value: lines.join('  \n')
+                }
+            };
+        }
+        return;
+    }
+}

package/dist/lsp/SemanticTokenProvider.d.ts

@@ -0,0 +1,6 @@
+import { AbstractSemanticTokenProvider, type AstNode, type SemanticTokenAcceptor } from 'langium';
+export declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+    protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void;
+    private highlightAstElement;
+    private highlightView;
+}

package/dist/lsp/SemanticTokenProvider.js

@@ -0,0 +1,245 @@
+import { AbstractSemanticTokenProvider } from 'langium';
+import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-protocol';
+import { ast } from '../ast';
+import { isElementRefHead } from '../elementRef';
+export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+    highlightElement(node, acceptor) {
+        const keyword = (keyword, _index) => acceptor({
+            node,
+            keyword,
+            type: SemanticTokenTypes.keyword,
+        });
+        if (ast.isElementRef(node) || ast.isStrictElementRef(node)) {
+            acceptor({
+                node,
+                property: 'el',
+                type: isElementRefHead(node) ? SemanticTokenTypes.variable : SemanticTokenTypes.property,
+            });
+            // acceptor({
+            //   node,
+            //   property: 'el',
+            //   type: SemanticTokenTypes.variable,
+            // })
+            return;
+        }
+        //   if (ast.isSpec(node)) {
+        //     keyword('spec')
+        //     return
+        //   }
+        if (ast.isWildcardExpression(node)) {
+            acceptor({
+                node,
+                property: 'isWildcard',
+                type: SemanticTokenTypes.variable
+            });
+            return;
+        }
+        if (ast.isRelationExpression(node) || ast.isIncomingExpression(node) || ast.isOutgoingExpression(node)) {
+            keyword('->');
+            return;
+        }
+        if (ast.isInOutExpression(node)) {
+            keyword('->', 0);
+            keyword('->', 1);
+            return;
+        }
+        if (ast.isRelation(node)) {
+            keyword('->');
+            if ('title' in node) {
+                acceptor({
+                    node,
+                    property: 'title',
+                    type: SemanticTokenTypes.string
+                });
+            }
+            return;
+        }
+        //   if (ast.isDynamicViewStep(node)) {
+        //     keyword(node.isReverse ? '<-' : '->')
+        //     if (hasTitle(node)) {
+        //       acceptor({
+        //         node,
+        //         property: 'title',
+        //         type: SemanticTokenTypes.string
+        //       })
+        //     }
+        //     return
+        //   }
+        //   if (ast.isStyleProperties(node)) {
+        //     keyword('style')
+        //     return
+        //   }
+        if (ast.isElementKind(node)) {
+            acceptor({
+                node,
+                property: 'name',
+                type: SemanticTokenTypes.type,
+                modifier: [
+                    SemanticTokenModifiers.definition,
+                ]
+            });
+            return;
+        }
+        //   if (ast.isElementKindSpec(node)) {
+        //     keyword('element')
+        //     // keyword('nested')
+        //     // if (node.nested.length > 0) {
+        //     //   acceptor({
+        //     //     node,
+        //     //     property: 'nested',
+        //     //     type: SemanticTokenTypes.type,
+        //     //   })
+        //     // }
+        //     // acceptor({
+        //     //   node,
+        //     //   property: 'kind',
+        //     //   type: SemanticTokenTypes.type,
+        //     // })
+        //     return
+        //   }
+        //   if (ast.isTagSpec(node)) {
+        //     keyword('tag')
+        //     acceptor({
+        //       node,
+        //       property: 'tag',
+        //       type: SemanticTokenTypes.enumMember
+        //     })
+        //     return
+        //   }
+        if (ast.isTags(node)) {
+            acceptor({
+                node,
+                property: 'value',
+                type: SemanticTokenTypes.macro
+            });
+            return;
+        }
+        if (ast.isTag(node)) {
+            acceptor({
+                node,
+                property: 'name',
+                type: SemanticTokenTypes.macro
+            });
+            return;
+        }
+        if (ast.isColorProperty(node) || ast.isShapeProperty(node)) {
+            acceptor({
+                node,
+                property: 'key',
+                type: SemanticTokenTypes.keyword,
+            });
+            acceptor({
+                node,
+                property: 'value',
+                type: SemanticTokenTypes.enumMember
+            });
+            return;
+        }
+        if (ast.isElementProperty(node) || ast.isRelationProperty(node) || ast.isViewProperty(node)) {
+            acceptor({
+                node,
+                property: 'key',
+                type: SemanticTokenTypes.keyword,
+            });
+            if ('value' in node) {
+                acceptor({
+                    node,
+                    property: 'value',
+                    type: SemanticTokenTypes.string
+                });
+            }
+            return;
+        }
+        if (ast.isModel(node)) {
+            keyword('model');
+            return;
+        }
+        if (ast.isModelViews(node)) {
+            keyword('views');
+            return;
+        }
+        if (ast.isElement(node)) {
+            return this.highlightAstElement(node, acceptor);
+        }
+        if (ast.isExtendElement(node)) {
+            keyword('extend');
+            return;
+        }
+        //   if (ast.isElementProperty(node) || ast.isRelationProperty(node) || ast.isViewProperty(node)) {
+        //     acceptor({
+        //       node,
+        //       property: 'key',
+        //       type: SemanticTokenTypes.property,
+        //       modifier: [SemanticTokenModifiers.definition]
+        //     })
+        //     if ('value' in node) {
+        //       acceptor({
+        //         node,
+        //         property: 'value',
+        //         type: SemanticTokenTypes.string
+        //       })
+        //     }
+        //     return
+        //   }
+        if (ast.isView(node)) {
+            return this.highlightView(node, acceptor);
+        }
+        //   if (ast.isDynamicViewSteps(node)) {
+        //     keyword('steps')
+        //     return
+        //   }
+        if (ast.isViewRuleStyle(node)) {
+            keyword('style');
+            return;
+        }
+        if (ast.isViewRuleExpression(node)) {
+            keyword(node.isInclude ? 'include' : 'exclude');
+            return;
+        }
+        //
+    }
+    highlightAstElement(node, acceptor) {
+        acceptor({
+            node,
+            property: 'name',
+            type: SemanticTokenTypes.variable,
+            modifier: [
+                SemanticTokenModifiers.declaration,
+            ]
+        });
+        acceptor({
+            node,
+            property: 'kind',
+            type: SemanticTokenTypes.keyword,
+            modifier: []
+        });
+        if ('title' in node) {
+            acceptor({
+                node,
+                property: 'title',
+                type: SemanticTokenTypes.string
+            });
+        }
+    }
+    highlightView(node, acceptor) {
+        if (node.name) {
+            acceptor({
+                node,
+                property: 'name',
+                type: SemanticTokenTypes.variable,
+            });
+        }
+        if (node.viewOf) {
+            acceptor({
+                node,
+                keyword: 'of',
+                type: SemanticTokenTypes.keyword
+            });
+        }
+        acceptor({
+            node,
+            keyword: 'view',
+            type: SemanticTokenTypes.keyword
+        });
+    }
+}

package/dist/lsp/index.d.ts

@@ -0,0 +1,4 @@
+export * from './CodeLensProvider';
+export * from './DocumentSymbolProvider';
+export * from './HoverProvider';
+export * from './SemanticTokenProvider';

package/dist/lsp/index.js

@@ -0,0 +1,4 @@
+export * from './CodeLensProvider';
+export * from './DocumentSymbolProvider';
+export * from './HoverProvider';
+export * from './SemanticTokenProvider';

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

@@ -0,0 +1,17 @@
+import { StreamImpl } from 'langium';
+import type { AstNodeDescription, AstNodeDescriptionProvider } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+import { Fqn } from '@likec4/core/types';
+export declare class FqnIndex {
+    #private;
+    private services;
+    protected readonly descriptions: AstNodeDescriptionProvider;
+    constructor(services: LikeC4Services);
+    get(el: ast.Element): Fqn | null;
+    byFqn(fqn: Fqn): readonly AstNodeDescription[];
+    directChildrenOf(parent: Fqn): import("langium").Stream<AstNodeDescription>;
+    uniqueDescedants(parent: Fqn): StreamImpl<IterableIterator<AstNodeDescription> | null, AstNodeDescription>;
+    private doIndexElements;
+    private cleanIndexedElements;
+}