@likec4/language-server 0.26.0 → 0.27.0

package/dist/lsp/DocumentSymbolProvider.js

@@ -3,11 +3,11 @@
  * 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';
 import { logger } from '../logger';
+import { isEmpty } from 'remeda';
 export class LikeC4DocumentSymbolProvider {
     services;
     constructor(services) {
@@ -28,10 +28,20 @@ export class LikeC4DocumentSymbolProvider {
         const specKeywordNode = findNodeForProperty(cstModel, 'name');
         if (!specKeywordNode)
             return [];
-        const specSymbols = [];
+        const specSymbols = astSpec.specs.flatMap(nd => {
+            if (ast.isSpecificationElementKind(nd)) {
+                return getElementKindSymbol(nd) ?? [];
+            }
+            else if (ast.isSpecificationTag(nd)) {
+                return getTagSymbol(nd) ?? [];
+            }
+            else {
+                return [];
+            }
+        });
         const getElementKindSymbol = (astKind) => {
-            invariant(astKind.$cstNode, 'SpecificationElementKind must have a CST node');
-            invariant(astKind.kind.$cstNode, 'SpecificationElementKind name must have a CST node');
+            if (!astKind.$cstNode || !astKind.kind.$cstNode || isEmpty(astKind.kind.name))
+                return null;
             return {
                 kind: SymbolKind.Class,
                 name: astKind.kind.name,
@@ -39,17 +49,9 @@ export class LikeC4DocumentSymbolProvider {
                 selectionRange: astKind.kind.$cstNode.range
             };
         };
-        for (const astKind of astSpec.elementKinds) {
-            try {
-                specSymbols.push(getElementKindSymbol(astKind));
-            }
-            catch (e) {
-                logger.error(e);
-            }
-        }
         const getTagSymbol = (astTag) => {
-            invariant(astTag.$cstNode, 'TagSpec must have a CST node');
-            invariant(astTag.tag.$cstNode, 'Tag name must have a CST node');
+            if (!astTag.$cstNode || !astTag.tag.$cstNode || isEmpty(astTag.tag.name))
+                return null;
             return {
                 kind: SymbolKind.EnumMember,
                 name: '#' + astTag.tag.name,
@@ -57,14 +59,6 @@ export class LikeC4DocumentSymbolProvider {
                 selectionRange: astTag.tag.$cstNode.range
             };
         };
-        for (const astTag of astSpec.tags) {
-            try {
-                specSymbols.push(getTagSymbol(astTag));
-            }
-            catch (e) {
-                logger.error(e);
-            }
-        }
         if (specSymbols.length === 0)
             return [];
         return [

package/dist/model/fqn-computation.js

@@ -1,7 +1,7 @@
 import { failExpectedNever } from '@likec4/core';
 import { Fqn } from '@likec4/core/types';
 import { MultiMap } from 'langium';
-import { isEmpty, isNil } from 'rambdax';
+import { isEmpty, isNil } from 'remeda';
 import { ElementOps, ast } from '../ast';
 import { strictElementRefFqn } from '../elementRef';
 export function computeDocumentFqn(document, services) {

package/dist/model/fqn-index.js

@@ -1,11 +1,11 @@
 import { nameFromFqn, parentFqn } from '@likec4/core/utils';
-import { DocumentState, DONE_RESULT, MultiMap, StreamImpl } from 'langium';
+import { DONE_RESULT, DocumentState, MultiMap, StreamImpl } from 'langium';
 import { isNil } from 'remeda';
 import { ElementOps, isLikeC4LangiumDocument } from '../ast';
 import { logger } from '../logger';
 import { computeDocumentFqn } from './fqn-computation';
 export function isFqnIndexedDocument(doc) {
-    return isLikeC4LangiumDocument(doc) && !isNil(doc.c4fqns);
+    return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns);
 }
 export class FqnIndex {
     services;

package/dist/model/model-builder.js

@@ -5,13 +5,13 @@ import { DocumentState, getDocument } from 'langium';
 import objectHash from 'object-hash';
 import { clone } from 'rambdax';
 import * as R from 'remeda';
+import stripIndent from 'strip-indent';
 import invariant from 'tiny-invariant';
 import { ElementViewOps, ast, cleanParsedModel, isLikeC4LangiumDocument, isValidLikeC4LangiumDocument, resolveRelationPoints, streamModel, toAutoLayout, toElementStyle } from '../ast';
 import { elementRef, strictElementRefFqn } from '../elementRef';
 import { logger } from '../logger';
 import { Rpc } from '../protocol';
 import { failExpectedNever } from '../utils';
-import stripIndent from 'strip-indent';
 export class LikeC4ModelBuilder {
     services;
     fqnIndex;
@@ -129,9 +129,9 @@ export class LikeC4ModelBuilder {
      */
     parseDocument(doc) {
         const { elements, relations, views, specification } = cleanParsedModel(doc);
-        const spec = doc.parseResult.value.specification;
-        if (spec) {
-            for (const { kind, style } of spec.elementKinds) {
+        const specs = doc.parseResult.value.specification?.specs.filter(ast.isSpecificationElementKind);
+        if (specs) {
+            for (const { kind, style } of specs) {
                 try {
                     const styleProps = toElementStyle(style?.props);
                     specification.kinds[kind.name] = {

package/dist/module.js

@@ -4,7 +4,7 @@ import { LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenP
 import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator } from './model';
 import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { registerProtocolHandlers } from './registerProtocolHandlers';
-import { LikeC4CodeLensProvider, LikeC4WorkspaceManager } from './shared';
+import { LikeC4CodeLensProvider, LikeC4DocumentLinkProvider, LikeC4WorkspaceManager } from './shared';
 import { registerValidationChecks } from './validation';
 import { logger } from './logger';
 function bind(Type) {
@@ -36,7 +36,8 @@ const LikeC4SharedModule = {
         WorkspaceManager: services => new LikeC4WorkspaceManager(services)
     },
     lsp: {
-        CodeLensProvider: services => new LikeC4CodeLensProvider(services)
+        CodeLensProvider: services => new LikeC4CodeLensProvider(services),
+        DocumentLinkProvider: services => new LikeC4DocumentLinkProvider(services)
     }
 };
 export function createLanguageServices(context) {

package/dist/references/scope-computation.js

@@ -1,5 +1,6 @@
 import { DefaultScopeComputation, MultiMap } from 'langium';
 import { ast } from '../ast';
+import { isEmpty } from 'remeda';
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
     services;
     constructor(services) {
@@ -9,28 +10,30 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     computeExports(document, _cancelToken) {
         const { specification, model, views } = document.parseResult.value;
         const docExports = [];
-        if (specification) {
-            for (const { kind } of specification.elementKinds) {
-                docExports.push(this.descriptions.createDescription(kind, kind.name, document));
-            }
-            for (const { tag } of specification.tags) {
-                docExports.push(this.descriptions.createDescription(tag, tag.name, document));
-                docExports.push(this.descriptions.createDescription(tag, '#' + tag.name, document));
+        if (specification && specification.specs.length > 0) {
+            for (const spec of specification.specs) {
+                if (ast.isSpecificationElementKind(spec) && spec.kind && !isEmpty(spec.kind.name)) {
+                    docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
+                    continue;
+                }
+                if (ast.isSpecificationTag(spec) && spec.tag && !isEmpty(spec.tag.name)) {
+                    docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
+                    docExports.push(this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document));
+                    continue;
+                }
             }
         }
-        // Filled later by FqnIndex (on IndexedContent phase)
-        document.c4fqns = undefined;
         // Only root model elements are exported
         if (model && model.elements.length > 0) {
             for (const elAst of model.elements) {
-                if (ast.isElement(elAst)) {
+                if (ast.isElement(elAst) && !isEmpty(elAst.name)) {
                     docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
                 }
             }
         }
         if (views && views.views.length > 0) {
             for (const viewAst of views.views) {
-                if ('name' in viewAst) {
+                if (viewAst.name && !isEmpty(viewAst.name)) {
                     docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
                 }
             }
@@ -54,7 +57,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
                 continue;
             }
             let subcontainer;
-            if (ast.isElement(el)) {
+            if (ast.isElement(el) && !isEmpty(el.name)) {
                 localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
                 subcontainer = el.body;
             }

package/dist/shared/DocumentLinkProvider.d.ts

@@ -0,0 +1,8 @@
+import type { LangiumDocument, LangiumSharedServices, MaybePromise, DocumentLinkProvider } from 'langium';
+import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver-protocol';
+export declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
+    private services;
+    constructor(services: LangiumSharedServices);
+    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
+}
+//# sourceMappingURL=DocumentLinkProvider.d.ts.map

package/dist/shared/DocumentLinkProvider.js

@@ -0,0 +1,37 @@
+import { findNodeForProperty, streamAllContents } from 'langium/lib/utils';
+import { ast, isParsedLikeC4LangiumDocument } from '../ast';
+import { logger } from '../logger';
+export class LikeC4DocumentLinkProvider {
+    services;
+    constructor(services) {
+        this.services = services;
+        //
+    }
+    getDocumentLinks(doc, _params) {
+        if (!isParsedLikeC4LangiumDocument(doc)) {
+            return [];
+        }
+        const base = new URL(doc.uri.toString());
+        return streamAllContents(doc.parseResult.value)
+            .filter(ast.isLinkProperty)
+            .flatMap((n) => {
+            try {
+                const u = new URL(n.value, base);
+                const valueCst = findNodeForProperty(n.$cstNode, 'value');
+                if (!valueCst) {
+                    return [];
+                }
+                return {
+                    range: valueCst.range,
+                    target: u.toString()
+                };
+            }
+            catch (e) {
+                logger.error(e);
+                return [];
+            }
+        })
+            .toArray();
+    }
+}
+//# sourceMappingURL=DocumentLinkProvider.js.map

package/dist/shared/index.d.ts

@@ -1,3 +1,4 @@
 export * from './CodeLensProvider';
 export * from './WorkspaceManager';
+export * from './DocumentLinkProvider';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/index.js

@@ -1,3 +1,4 @@
 export * from './CodeLensProvider';
 export * from './WorkspaceManager';
+export * from './DocumentLinkProvider';
 //# sourceMappingURL=index.js.map