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

@@ -12,7 +12,7 @@ export declare class LikeC4ModelBuilder {
     /**
      * @returns if the document was changed
      */
-    protected parseDocument(doc: LikeC4LangiumDocument): boolean;
+    protected parseDocument(doc: LikeC4LangiumDocument): void;
     private parseElement;
     private parseRelation;
     private parseElementExpression;
@@ -22,6 +22,7 @@ export declare class LikeC4ModelBuilder {
     protected resolveFqn(node: ast.Element | ast.ExtendElement): c4.Fqn;
     private getAstNodePath;
     private convertTags;
+    private scheduledCb;
     private notifyClient;
 }
 //# sourceMappingURL=model-builder.d.ts.map

package/dist/model/model-builder.js

@@ -6,11 +6,12 @@ import objectHash from 'object-hash';
 import { clone, isNil } from 'rambdax';
 import * as R from 'remeda';
 import invariant from 'tiny-invariant';
-import { ElementViewOps, ast, c4hash, cleanParsedModel, isLikeC4LangiumDocument, isParsedLikeC4LangiumDocument, resolveRelationPoints, streamModel, toAutoLayout, toElementStyle } from '../ast';
+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;
@@ -25,17 +26,20 @@ export class LikeC4ModelBuilder {
                 if (cancelToken.isCancellationRequested) {
                     break;
                 }
+                if (!isLikeC4LangiumDocument(doc)) {
+                    continue;
+                }
+                countOfChangedDocs++;
                 try {
-                    if (isLikeC4LangiumDocument(doc) && this.parseDocument(doc)) {
-                        countOfChangedDocs++;
-                    }
+                    this.parseDocument(doc);
                 }
                 catch (e) {
                     logger.error(`Error parsing document ${doc.uri.toString()}`);
+                    logger.error(e);
                 }
             }
             if (countOfChangedDocs > 0 && !cancelToken.isCancellationRequested) {
-                void this.notifyClient();
+                this.notifyClient();
             }
         });
     }
@@ -43,7 +47,7 @@ export class LikeC4ModelBuilder {
         return this.services.shared.lsp.Connection;
     }
     documents() {
-        return this.langiumDocuments.all.toArray().filter(isParsedLikeC4LangiumDocument);
+        return this.langiumDocuments.all.toArray().filter(isValidLikeC4LangiumDocument);
     }
     buildModel() {
         const docs = this.documents();
@@ -56,7 +60,7 @@ export class LikeC4ModelBuilder {
             const c4Specification = {
                 kinds: {}
             };
-            R.pipe(R.map(docs, R.prop('c4Specification')), R.forEach(spec => Object.assign(c4Specification.kinds, spec.kinds)));
+            R.forEach(R.map(docs, R.prop('c4Specification')), spec => Object.assign(c4Specification.kinds, spec.kinds));
             const toModelElement = (el) => {
                 const kind = c4Specification.kinds[el.kind];
                 if (kind) {
@@ -166,9 +170,9 @@ export class LikeC4ModelBuilder {
                 }
             }
         }
-        const prevHash = doc.c4hash ?? '';
-        doc.c4hash = c4hash(doc);
-        return prevHash !== doc.c4hash;
+        // const prevHash = doc.c4hash ?? ''
+        // doc.c4hash = c4hash(doc)
+        // return prevHash !== doc.c4hash
     }
     parseElement(astNode) {
         const id = this.resolveFqn(astNode);
@@ -189,7 +193,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 } : {})
@@ -331,12 +335,21 @@ export class LikeC4ModelBuilder {
     convertTags(el) {
         return el.tags?.value.map(tagRef => tagRef.ref?.name) ?? [];
     }
-    async notifyClient() {
+    scheduledCb = null;
+    notifyClient() {
         const connection = this.connection;
         if (!connection) {
             return;
         }
-        await connection.sendNotification(Rpc.onDidChangeModel);
+        if (this.scheduledCb) {
+            logger.debug('debounce scheduled onDidChangeModel');
+            clearTimeout(this.scheduledCb);
+        }
+        this.scheduledCb = setTimeout(() => {
+            logger.debug('send onDidChangeModel');
+            this.scheduledCb = null;
+            void connection.sendNotification(Rpc.onDidChangeModel, '');
+        }, 350);
     }
 }
 //# sourceMappingURL=model-builder.js.map

package/dist/module.js

@@ -6,6 +6,7 @@ import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { registerProtocolHandlers } from './registerProtocolHandlers';
 import { LikeC4CodeLensProvider, LikeC4WorkspaceManager } from './shared';
 import { registerValidationChecks } from './validation';
+import { logger } from './logger';
 function bind(Type) {
     return (services) => new Type(services);
 }
@@ -39,15 +40,29 @@ const LikeC4SharedModule = {
     }
 };
 export function createLanguageServices(context) {
-    // const connection = context.connection
-    // if (connection) {
-    //   logger.log = connection.console.log.bind(connection.console)
-    //   logger.info = connection.console.info.bind(connection.console)
-    //   logger.warn = connection.console.warn.bind(connection.console)
-    //   logger.error = connection.console.error.bind(connection.console)
-    //   logger.debug = connection.tracer.log.bind(connection.tracer)
-    //   logger.trace = connection.tracer.log.bind(connection.tracer)
-    // }
+    const connection = context?.connection;
+    if (connection) {
+        const log = (method) => (message) => {
+            try {
+                console[method](message);
+                connection.console[method](String(message));
+                if (method === 'error') {
+                    connection.telemetry.logEvent({ eventName: 'error', message });
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        };
+        logger.log = log('log');
+        logger.info = log('info');
+        logger.warn = log('warn');
+        logger.error = log('error');
+        logger.trace = logger.debug = (message) => {
+            console.debug(message);
+            connection.tracer.log(message);
+        };
+    }
     const moduleContext = {
         ...EmptyFileSystem,
         ...context

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/references/scope-computation.js

@@ -18,19 +18,17 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
                 docExports.push(this.descriptions.createDescription(tag, '#' + tag.name, document));
             }
         }
+        // Filled later by FqnIndex (on IndexedContent phase)
         document.c4fqns = undefined;
-        if (model) {
+        // Only root model elements are exported
+        if (model && model.elements.length > 0) {
             for (const elAst of model.elements) {
                 if (ast.isElement(elAst)) {
                     docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
                 }
             }
         }
-        // const c4fqns = document.c4fqns
-        // logger.debug(`doc ${document.uri.path}:
-        //  fqns: ${c4fqns ? Array.from(c4fqns.keys()).join(', ') : '--'}
-        // `)
-        if (views) {
+        if (views && views.views.length > 0) {
             for (const viewAst of views.views) {
                 if ('name' in viewAst) {
                     docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));

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 Promise.resolve(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, ({ id }, _cancelToken) => {
-        try {
-            return Promise.resolve(modelLocator.locateRelation(id));
-        }
-        catch (e) {
-            return Promise.reject(e);
-        }
+    connection.onRequest(Rpc.locateRelation, ({ id }) => {
+        return modelLocator.locateRelation(id);
     });
-    connection.onRequest(Rpc.locateView, ({ id }, _cancelToken) => {
-        try {
-            return Promise.resolve(modelLocator.locateView(id));
-        }
-        catch (e) {
-            return Promise.reject(e);
-        }
+    connection.onRequest(Rpc.locateView, ({ id }) => {
+        return modelLocator.locateView(id);
     });
 }
 //# sourceMappingURL=registerProtocolHandlers.js.map