@likec4/language-server 0.24.0 → 0.26.0

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -5,7 +5,7 @@
  ******************************************************************************/
 /// <reference types="react" />
 import { type DocumentSymbolProvider, type MaybePromise } from 'langium';
-import { type DocumentSymbol } from 'vscode-languageserver';
+import { type DocumentSymbol } from 'vscode-languageserver-protocol';
 import { type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {

package/dist/lsp/DocumentSymbolProvider.js

@@ -5,7 +5,7 @@
  ******************************************************************************/
 import invariant from 'tiny-invariant';
 import { findNodeForProperty } from 'langium';
-import { SymbolKind } from 'vscode-languageserver';
+import { SymbolKind } from 'vscode-languageserver-protocol';
 import { ast } from '../ast';
 import { logger } from '../logger';
 export class LikeC4DocumentSymbolProvider {

package/dist/lsp/HoverProvider.d.ts

@@ -1,5 +1,5 @@
 import { type AstNode, AstNodeHoverProvider, type MaybePromise } from 'langium';
-import type { Hover } from 'vscode-languageserver';
+import type { Hover } from 'vscode-languageserver-protocol';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4HoverProvider extends AstNodeHoverProvider {
     private locator;

package/dist/lsp/SemanticTokenProvider.js

@@ -1,5 +1,5 @@
 import { AbstractSemanticTokenProvider } from 'langium';
-import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver';
+import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-protocol';
 import { ast } from '../ast';
 import { isElementRefHead } from '../elementRef';
 export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
@@ -7,7 +7,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         const keyword = (keyword, _index) => acceptor({
             node,
             keyword,
-            type: SemanticTokenTypes.keyword
+            type: SemanticTokenTypes.keyword,
+            modifier: [SemanticTokenModifiers.defaultLibrary]
         });
         if (ast.isElementRef(node) || ast.isStrictElementRef(node)) {
             acceptor({
@@ -25,11 +26,17 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             });
             return;
         }
-        if (ast.isRelationExpression(node) ||
+        if (ast.isRelation(node) ||
+            ast.isRelationExpression(node) ||
             ast.isIncomingExpression(node) ||
+            ast.isInOutExpression(node) ||
             ast.isOutgoingExpression(node)) {
-            keyword('->');
-            return;
+            acceptor({
+                node,
+                property: 'arr',
+                type: SemanticTokenTypes.keyword,
+                modifier: [SemanticTokenModifiers.defaultLibrary]
+            });
         }
         if (ast.isElementKindExpression(node) || ast.isElementTagExpression(node)) {
             keyword('element');
@@ -54,13 +61,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
                 return;
             }
         }
-        if (ast.isInOutExpression(node)) {
-            keyword('->', 0);
-            keyword('->', 1);
-            return;
-        }
         if (ast.isRelation(node)) {
-            keyword('->');
             if ('title' in node) {
                 acceptor({
                     node,
@@ -102,11 +103,16 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
                 node,
                 property: 'key',
                 type: SemanticTokenTypes.keyword
+                // type: SemanticTokenTypes.property,
+                // modifier: [
+                //   SemanticTokenModifiers.readonly,
+                //   SemanticTokenModifiers.declaration
+                // ]
             });
             acceptor({
                 node,
                 property: 'value',
-                type: SemanticTokenTypes.enumMember
+                type: SemanticTokenTypes.enum
             });
             return;
         }
@@ -115,6 +121,11 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
                 node,
                 property: 'key',
                 type: SemanticTokenTypes.keyword
+                // type: SemanticTokenTypes.property,
+                // modifier: [
+                //   SemanticTokenModifiers.readonly,
+                //   SemanticTokenModifiers.declaration
+                // ]
             });
             acceptor({
                 node,
@@ -151,20 +162,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             type: SemanticTokenTypes.keyword,
             modifier: []
         });
-        if ('title' in node) {
-            acceptor({
-                node,
-                property: 'title',
-                type: SemanticTokenTypes.string
-            });
-        }
     }
     highlightView(node, acceptor) {
-        acceptor({
-            node,
-            keyword: 'view',
-            type: SemanticTokenTypes.keyword
-        });
         if (node.name) {
             acceptor({
                 node,

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 { DocumentState, DONE_RESULT, 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) && !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,9 +1,9 @@
-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 invariant from 'tiny-invariant';
 import { ElementViewOps, ast, cleanParsedModel, isLikeC4LangiumDocument, isValidLikeC4LangiumDocument, resolveRelationPoints, streamModel, toAutoLayout, toElementStyle } from '../ast';
@@ -11,6 +11,7 @@ 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;
@@ -46,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();
@@ -72,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) {
@@ -87,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;
@@ -97,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);
@@ -192,7 +201,7 @@ export class LikeC4ModelBuilder {
             astPath,
             title: title ?? astNode.name,
             ...(technology && { technology }),
-            ...(description && { description }),
+            ...(description && { description: stripIndent(description).trim() }),
             ...(tags.length > 0 ? { tags } : {}),
             ...(shape && shape !== DefaultElementShape ? { shape } : {}),
             ...(color && color !== DefaultThemeColor ? { color } : {})
@@ -345,10 +354,10 @@ export class LikeC4ModelBuilder {
             clearTimeout(this.scheduledCb);
         }
         this.scheduledCb = setTimeout(() => {
-            this.scheduledCb = null;
             logger.debug('send onDidChangeModel');
-            void connection.sendNotification(Rpc.onDidChangeModel);
-        }, 300);
+            this.scheduledCb = null;
+            void connection.sendNotification(Rpc.onDidChangeModel, '');
+        }, 350);
     }
 }
 //# sourceMappingURL=model-builder.js.map

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

@@ -46,6 +46,9 @@ export function createLanguageServices(context) {
             try {
                 console[method](message);
                 connection.console[method](String(message));
+                if (method === 'error') {
+                    connection.telemetry.logEvent({ eventName: 'error', message });
+                }
             }
             catch (error) {
                 console.error(error);

package/dist/protocol.d.ts

@@ -1,6 +1,6 @@
 import type { Fqn, LikeC4Model, RelationID, ViewID } from '@likec4/core';
 import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
-import { NotificationType0, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+import { NotificationType, RequestType0, RequestType } from 'vscode-languageserver-protocol';
 interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
@@ -16,7 +16,7 @@ export declare const locateView: RequestType<{
     id: ViewID;
 }, Location | null, void>;
 export declare const Rpc: {
-    readonly onDidChangeModel: NotificationType0;
+    readonly onDidChangeModel: NotificationType<string>;
     readonly fetchModel: RequestType0<{
         model: LikeC4Model | null;
     }, void>;

package/dist/protocol.js

@@ -1,6 +1,6 @@
-import { NotificationType0, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+import { NotificationType, RequestType0, RequestType } from 'vscode-languageserver-protocol';
 //#region From server
-const onDidChangeModel = new NotificationType0('likec4/onDidChangeModel');
+const onDidChangeModel = new NotificationType('likec4/onDidChangeModel');
 //#endregion
 //#region To server
 const fetchModel = new RequestType0('likec4/fetchModel');

package/dist/registerProtocolHandlers.js

@@ -67,29 +67,14 @@ We rebuild: [
         }
         await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
     });
-    connection.onRequest(Rpc.locateElement, async ({ element, property }, _cancelToken) => {
-        try {
-            return modelLocator.locateElement(element, property ?? 'name');
-        }
-        catch (e) {
-            return Promise.reject(e);
-        }
+    connection.onRequest(Rpc.locateElement, ({ element, property }) => {
+        return modelLocator.locateElement(element, property ?? 'name');
     });
-    connection.onRequest(Rpc.locateRelation, async ({ id }, _cancelToken) => {
-        try {
-            return modelLocator.locateRelation(id);
-        }
-        catch (e) {
-            return Promise.reject(e);
-        }
+    connection.onRequest(Rpc.locateRelation, ({ id }) => {
+        return modelLocator.locateRelation(id);
     });
-    connection.onRequest(Rpc.locateView, async ({ id }, _cancelToken) => {
-        try {
-            return modelLocator.locateView(id);
-        }
-        catch (e) {
-            return Promise.reject(e);
-        }
+    connection.onRequest(Rpc.locateView, ({ id }) => {
+        return modelLocator.locateView(id);
     });
 }
 //# sourceMappingURL=registerProtocolHandlers.js.map