@likec4/language-server 0.25.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.d.ts

@@ -1,5 +1,5 @@
 import type { Fqn } from '@likec4/core/types';
-import type { LangiumDocuments } from 'langium';
+import type { LangiumDocument, LangiumDocuments } from 'langium';
 import { StreamImpl } from 'langium';
 import type { ast } from '../ast';
 import { type LikeC4LangiumDocument } from '../ast';
@@ -7,6 +7,7 @@ import type { LikeC4Services } from '../module';
 type FqnIndexedDocument = Omit<LikeC4LangiumDocument, 'c4fqns'> & {
     c4fqns: NonNullable<LikeC4LangiumDocument['c4fqns']>;
 };
+export declare function isFqnIndexedDocument(doc: LangiumDocument): doc is FqnIndexedDocument;
 export interface FqnIndexEntry {
     fqn: Fqn;
     name: string;
@@ -24,7 +25,7 @@ export declare class FqnIndex {
         path: string;
         doc: FqnIndexedDocument;
     }>;
-    directChildrenOf(parent: Fqn): import("langium").Stream<FqnIndexEntry>;
+    directChildrenOf(parent: Fqn): StreamImpl<IterableIterator<FqnIndexEntry> | null, FqnIndexEntry>;
     uniqueDescedants(parent: Fqn): StreamImpl<IterableIterator<FqnIndexEntry> | null, FqnIndexEntry>;
 }
 export {};

package/dist/model/fqn-index.js

@@ -1,10 +1,12 @@
 import { nameFromFqn, parentFqn } from '@likec4/core/utils';
-import { DocumentState, DONE_RESULT, getDocument, 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';
-const isFqnIndexedDocument = (doc) => isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns);
+export function isFqnIndexedDocument(doc) {
+    return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns);
+}
 export class FqnIndex {
     services;
     langiumDocuments;
@@ -31,54 +33,70 @@ export class FqnIndex {
         return this.documents().flatMap(doc => doc.c4fqns.entries().map(([fqn, path]) => ({ fqn, path, doc })));
     }
     get(el) {
-        let fqn = ElementOps.readId(el) ?? null;
-        if (fqn) {
-            const doc = getDocument(el);
-            if (isFqnIndexedDocument(doc) && doc.c4fqns.has(fqn)) {
-                return fqn;
-            }
-            const path = this.services.workspace.AstNodeLocator.getAstNodePath(el);
-            logger.error(`Clean cached FQN ${fqn} at ${path}`);
-            ElementOps.writeId(el, null);
-            fqn = null;
-        }
-        return fqn;
+        return ElementOps.readId(el) ?? null;
+        // if (fqn) {
+        //   const doc = getDocument(el)
+        //   if (isFqnIndexedDocument(doc) && doc.c4fqns.has(fqn)) {
+        //     return fqn
+        //   }
+        //   const path = this.services.workspace.AstNodeLocator.getAstNodePath(el)
+        //   logger.error(`Clean cached FQN ${fqn} at ${path}`)
+        //   ElementOps.writeId(el, null)
+        //   fqn = null
+        // }
+        // return fqn
     }
     byFqn(fqn) {
-        return this.documents()
-            .flatMap(doc => {
+        return this.documents().flatMap(doc => {
             return doc.c4fqns.get(fqn).map(path => ({ path, doc }));
         });
     }
     directChildrenOf(parent) {
-        return this
-            .entries()
-            .filter(e => parentFqn(e.fqn) === parent)
-            .map((e) => ({ ...e, name: nameFromFqn(e.fqn) }));
+        return new StreamImpl(() => {
+            const children = new MultiMap(this.entries()
+                .filter(e => parentFqn(e.fqn) === parent)
+                .map((e) => {
+                const name = nameFromFqn(e.fqn);
+                const entry = { ...e, name };
+                return [name, entry];
+            })
+                .toArray());
+            if (children.size === 0) {
+                return null;
+            }
+            return children
+                .entriesGroupedByKey()
+                .flatMap(([_name, descrs]) => (descrs.length === 1 ? descrs : []))
+                .iterator();
+        }, iterator => {
+            if (iterator) {
+                return iterator.next();
+            }
+            return DONE_RESULT;
+        });
     }
     uniqueDescedants(parent) {
         return new StreamImpl(() => {
             const prefix = `${parent}.`;
-            const children = [];
             const childrenNames = new Set();
             const descedants = [];
-            this.entries().forEach(e => {
-                if (e.fqn.startsWith(prefix)) {
-                    const name = nameFromFqn(e.fqn);
-                    const entry = { ...e, name };
-                    if (parentFqn(e.fqn) === parent) {
-                        childrenNames.add(name);
-                        children.push(entry);
-                    }
-                    else {
-                        descedants.push(entry);
-                    }
+            const nested = new MultiMap();
+            this.entries()
+                .filter(e => e.fqn.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 (children.length + descedants.length === 0) {
+            if (nested.size + descedants.length === 0) {
                 return null;
             }
-            const nested = new MultiMap(children.map(entry => [entry.name, entry]));
             for (const descedant of descedants) {
                 if (!childrenNames.has(descedant.name)) {
                     nested.add(descedant.name, descedant);

package/dist/model/model-builder.js

@@ -1,17 +1,17 @@
-import { computeViews } from '@likec4/core';
+import { ModelIndex, assignNavigateTo, computeView } from '@likec4/core';
 import { DefaultElementShape, DefaultThemeColor } from '@likec4/core/types';
 import { compareByFqnHierarchically, parentFqn } from '@likec4/core/utils';
 import { DocumentState, getDocument } from 'langium';
 import objectHash from 'object-hash';
-import { clone, isNil } from 'rambdax';
+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;
@@ -47,7 +47,7 @@ export class LikeC4ModelBuilder {
         return this.services.shared.lsp.Connection;
     }
     documents() {
-        return this.langiumDocuments.all.toArray().filter(isValidLikeC4LangiumDocument);
+        return this.langiumDocuments.all.filter(isValidLikeC4LangiumDocument).toArray();
     }
     buildModel() {
         const docs = this.documents();
@@ -73,10 +73,6 @@ export class LikeC4ModelBuilder {
                 }
                 return null;
             };
-            const toModelRelation = (rel) => {
-                const { astPath, ...model } = rel;
-                return model;
-            };
             const elements = R.pipe(R.flatMap(docs, d => d.c4Elements), R.map(toModelElement), R.compact, R.sort(compareByFqnHierarchically), R.reduce((acc, el) => {
                 const parent = parentFqn(el.id);
                 if (!parent || parent in acc) {
@@ -88,7 +84,18 @@ export class LikeC4ModelBuilder {
                 }
                 return acc;
             }, {}));
-            const relations = R.pipe(R.flatMap(docs, d => d.c4Relations), R.map(toModelRelation), R.filter(({ source, target }) => source in elements && target in elements), R.mapToObj(r => [r.id, r]));
+            const toModelRelation = ({ astPath, source, target, ...model }) => {
+                if (source in elements && target in elements) {
+                    return {
+                        source,
+                        target,
+                        ...model
+                    };
+                }
+                return null;
+            };
+            const relations = R.pipe(R.flatMap(docs, d => d.c4Relations), R.map(toModelRelation), R.compact, R.mapToObj(r => [r.id, r]));
+            const modelIndex = ModelIndex.from({ elements, relations });
             const toModelView = (view) => {
                 // eslint-disable-next-line prefer-const
                 let { astPath, rules, title, ...model } = view;
@@ -98,18 +105,19 @@ export class LikeC4ModelBuilder {
                 if (!title && view.id === 'index') {
                     title = 'Landscape view';
                 }
-                return {
+                return computeView({
                     ...model,
                     ...(title && { title }),
                     rules: clone(rules)
-                };
+                }, modelIndex);
             };
-            const views = R.pipe(docs, R.flatMap(d => d.c4Views), R.map(toModelView), R.filter(v => isNil(v.viewOf) || v.viewOf in elements), R.mapToObj(v => [v.id, v]));
-            return computeViews({
+            const views = R.pipe(R.flatMap(docs, d => d.c4Views), R.map(toModelView), R.compact);
+            assignNavigateTo(views);
+            return {
                 elements,
                 relations,
-                views
-            });
+                views: R.mapToObj(views, v => [v.id, v])
+            };
         }
         catch (e) {
             logger.error(e);
@@ -121,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/model/model-locator.js

@@ -1,5 +1,5 @@
-import { findNodeForKeyword, findNodeForProperty, getDocument } from 'langium';
-import { ast, isParsedLikeC4LangiumDocument } from '../ast';
+import { findNodeForProperty, getDocument } from 'langium';
+import { ElementOps, ast, isParsedLikeC4LangiumDocument } from '../ast';
 export class LikeC4ModelLocator {
     services;
     fqnIndex;
@@ -10,21 +10,21 @@ export class LikeC4ModelLocator {
         this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     }
     documents() {
-        return this.langiumDocuments.all.toArray().filter(isParsedLikeC4LangiumDocument);
+        return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument);
     }
     getParsedElement(astNode) {
+        const fqn = ElementOps.readId(astNode) ?? null;
+        if (!fqn)
+            return null;
         const doc = getDocument(astNode);
         if (!isParsedLikeC4LangiumDocument(doc)) {
             return null;
         }
-        const fqn = this.fqnIndex.get(astNode);
-        if (!fqn)
-            return null;
         return doc.c4Elements.find(e => e.id === fqn) ?? null;
     }
     locateElement(fqn, property = 'name') {
         for (const doc of this.documents()) {
-            if (doc.c4fqns && !doc.c4fqns.has(fqn)) {
+            if (!doc.c4fqns?.has(fqn)) {
                 continue;
             }
             const element = doc.c4Elements.find(e => e.id === fqn);
@@ -68,7 +68,7 @@ export class LikeC4ModelLocator {
                     };
                 }
             }
-            const targetNode = findNodeForKeyword(node.$cstNode, '->');
+            const targetNode = findNodeForProperty(node.$cstNode, 'arr');
             if (!targetNode) {
                 return null;
             }

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