@likec4/language-server 1.24.1 → 1.25.1

package/dist/lsp/CodeLensProvider.js

@@ -1,4 +1,4 @@
-import { DocumentState, interruptAndCheck } from "langium";
+import { DocumentState } from "langium";
 import { isLikeC4LangiumDocument, ViewOps } from "../ast.js";
 import { logger } from "../logger.js";
 export class LikeC4CodeLensProvider {
@@ -11,13 +11,9 @@ export class LikeC4CodeLensProvider {
     }
     if (doc.state <= DocumentState.Linked) {
       logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
-      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
-      logger.debug(`Document ${doc.uri.path} is validated`);
+      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
+      logger.debug(`Document is linked`);
     }
-    if (cancelToken) {
-      await interruptAndCheck(cancelToken);
-    }
-    this.services.likec4.ModelParser.parse(doc);
     const views = doc.parseResult.value.views.flatMap((v) => v.views);
     return views.flatMap((ast) => {
       const viewId = ViewOps.readId(ast);

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -1,7 +1,8 @@
-import { type AstNode, type MaybePromise } from 'langium';
+import { type AstNode, type LangiumDocument } from 'langium';
 import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp';
+import type { CancellationToken, DocumentSymbolParams } from 'vscode-languageserver';
 import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types';
-import { type LikeC4LangiumDocument, ast } from '../ast';
+import { ast } from '../ast';
 import type { LikeC4ModelLocator, LikeC4ModelParser } from '../model';
 import type { LikeC4Services } from '../module';
 import type { LikeC4NameProvider } from '../references';
@@ -12,7 +13,7 @@ export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvi
     protected readonly parser: LikeC4ModelParser;
     protected readonly locator: LikeC4ModelLocator;
     constructor(services: LikeC4Services);
-    getSymbols({ parseResult: { value: { specifications, models, deployments, views, likec4lib }, }, }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]>;
+    getSymbols(doc: LangiumDocument, _params: DocumentSymbolParams, cancelToken?: CancellationToken): Promise<DocumentSymbol[]>;
     protected getLikec4LibSymbol(astLib: ast.LikeC4Lib): DocumentSymbol[];
     protected getSpecSymbol(astSpec: ast.SpecificationRule): DocumentSymbol[];
     protected getModelSymbol(astModel: ast.Model): DocumentSymbol[];

package/dist/lsp/DocumentSymbolProvider.js

@@ -1,10 +1,11 @@
 import { nonexhaustive } from "@likec4/core";
-import { AstUtils, GrammarUtils } from "langium";
+import { AstUtils, DocumentState, GrammarUtils } from "langium";
 import { filter, isEmpty, isTruthy, map, pipe } from "remeda";
 import { SymbolKind } from "vscode-languageserver-types";
-import { ast } from "../ast.js";
-import { logWarnError } from "../logger.js";
+import { ast, isLikeC4LangiumDocument } from "../ast.js";
+import { logger as rootLogger, logWarnError } from "../logger.js";
 import { readStrictFqn } from "../utils/elementRef.js";
+const logger = rootLogger.getChild("DocumentSymbolProvider");
 export class LikeC4DocumentSymbolProvider {
   constructor(services) {
     this.services = services;
@@ -17,11 +18,20 @@ export class LikeC4DocumentSymbolProvider {
   nameProvider;
   parser;
   locator;
-  getSymbols({
-    parseResult: {
-      value: { specifications, models, deployments, views, likec4lib }
+  async getSymbols(doc, _params, cancelToken) {
+    if (!isLikeC4LangiumDocument(doc)) {
+      return [];
     }
-  }) {
+    if (doc.state <= DocumentState.Linked) {
+      logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
+      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
+      logger.debug(`document is Linked`);
+    }
+    const {
+      parseResult: {
+        value: { specifications, models, deployments, views, likec4lib }
+      }
+    } = doc;
     return [
       ...likec4lib.map((l) => () => this.getLikec4LibSymbol(l)),
       ...specifications.map((s) => () => this.getSpecSymbol(s)),

package/dist/model/model-builder.js

@@ -8,13 +8,17 @@ import {
   Disposable,
   DocumentState
 } from "langium";
+import prettyMs from "pretty-ms";
 import {
   filter,
   groupBy,
+  isNot,
   mapToObj,
   pipe,
+  prop,
   values
 } from "remeda";
+import { isLikeC4Builtin } from "../likec4lib.js";
 import { logger as mainLogger, logWarnError } from "../logger.js";
 import { ADisposable } from "../utils/index.js";
 import { assignNavigateTo } from "../view-utils/index.js";
@@ -45,7 +49,10 @@ export class LikeC4ModelBuilder extends ADisposable {
       this.DocumentBuilder.onBuildPhase(
         DocumentState.Validated,
         (docs, _cancelToken) => {
-          this.notifyListeners(docs.map((d) => d.uri));
+          const validated = docs.map(prop("uri")).filter(isNot(isLikeC4Builtin));
+          if (validated.length > 0) {
+            this.notifyListeners(validated);
+          }
         }
       )
     );
@@ -64,7 +71,6 @@ export class LikeC4ModelBuilder extends ADisposable {
     }
     const cache = this.cache;
     return cache.get(CACHE_KEY_PARSED_MODEL, () => {
-      logger.debug("unsafeSyncParseModel ({docslength} docs)", { docslength: docs.length });
       return buildModel(docs);
     });
   }
@@ -72,13 +78,18 @@ export class LikeC4ModelBuilder extends ADisposable {
     const cache = this.cache;
     const cached = cache.get(CACHE_KEY_PARSED_MODEL);
     if (cached) {
-      return await Promise.resolve(cached);
+      logger.debug("parseModel from cache");
+      return cached;
     }
     if (this.LangiumDocuments.all.some((doc) => doc.state < DocumentState.Validated)) {
       logger.debug("parseModel: waiting for documents to be validated");
       await this.DocumentBuilder.waitUntil(DocumentState.Validated, cancelToken);
+      logger.debug("parseModel: documents are validated");
     }
-    return this.unsafeSyncParseModel();
+    const t0 = performance.now();
+    const result = this.unsafeSyncParseModel();
+    logger.debug(`parseModel in ${prettyMs(performance.now() - t0)}`);
+    return result;
   }
   previousViews = {};
   /**
@@ -126,13 +137,18 @@ export class LikeC4ModelBuilder extends ADisposable {
     const cache = this.cache;
     const cached = cache.get(CACHE_KEY_COMPUTED_MODEL);
     if (cached) {
-      return await Promise.resolve(cached);
+      logger.debug("buildLikeC4Model from cache");
+      return cached;
     }
+    const t0 = performance.now();
     const model = await this.parseModel(cancelToken);
     if (!model) {
+      logger.debug("buildLikeC4Model: no model");
       return LikeC4Model.EMPTY;
     }
-    return this.unsafeSyncBuildModel();
+    const result = this.unsafeSyncBuildModel();
+    logger.debug(`buildLikeC4Model in ${prettyMs(performance.now() - t0)}`);
+    return result;
   }
   async computeView(viewId, cancelToken) {
     const cache = this.cache;
@@ -147,9 +163,10 @@ export class LikeC4ModelBuilder extends ADisposable {
     return cache.get(cacheKey, () => {
       const view = parsed.views[viewId];
       if (!view) {
-        logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
+        logger.warn`computeView: cant find view ${viewId}`;
         return null;
       }
+      logger.debug`computeView: ${viewId}`;
       const computeView = LikeC4Model.makeCompute(parsed);
       const result = computeView(view);
       if (!result.isSuccess) {

package/dist/model-change/ModelChanges.d.ts

@@ -1,13 +1,13 @@
 import { Location, Range, TextEdit } from 'vscode-languageserver-types';
 import { type ParsedLikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
-import type { ChangeViewRequestParams } from '../protocol';
+import type { ChangeView } from '../protocol';
 export declare class LikeC4ModelChanges {
     private services;
     private locator;
     constructor(services: LikeC4Services);
-    applyChange(changeView: ChangeViewRequestParams): Promise<Location | null>;
-    protected convertToTextEdit({ viewId, change }: ChangeViewRequestParams): {
+    applyChange(changeView: ChangeView.Params): Promise<Location | null>;
+    protected convertToTextEdit({ viewId, change }: ChangeView.Params): {
         doc: ParsedLikeC4LangiumDocument;
         modifiedRange: Range;
         edits: TextEdit[];

package/dist/protocol.d.ts

@@ -1,79 +1,106 @@
-import type { ComputedLikeC4Model, ComputedView, DiagramView, Fqn, ParsedLikeC4Model, RelationId, ViewChange, ViewId } from '@likec4/core';
+import type { ComputedLikeC4Model, ComputedView, DiagramView, Fqn, LayoutedLikeC4Model, RelationId, ViewChange, ViewId } from '@likec4/core';
 import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
 import type { DiagnosticSeverity, DocumentUri, Location, Position } from 'vscode-languageserver-types';
 export declare const onDidChangeModel: NotificationType<string>;
 export type OnDidChangeModelNotification = typeof onDidChangeModel;
-export declare const fetchModel: RequestType0<{
-    model: ParsedLikeC4Model | null;
-}, void>;
-export type FetchModelRequest = typeof fetchModel;
-export declare const fetchComputedModel: RequestType<{
-    cleanCaches?: boolean | undefined;
-}, {
-    model: ComputedLikeC4Model | null;
-}, void>;
-export type FetchComputedModelRequest = typeof fetchComputedModel;
-export declare const computeView: RequestType<{
-    viewId: ViewId;
-}, {
-    view: ComputedView | null;
-}, void>;
-export type ComputeViewRequest = typeof computeView;
+export declare namespace FetchComputedModel {
+    type Params = {
+        cleanCaches?: boolean | undefined;
+    };
+    type Res = {
+        model: ComputedLikeC4Model | null;
+    };
+    const Req: RequestType<Params, Res, void>;
+    type Req = typeof Req;
+}
+export declare namespace ComputeView {
+    type Params = {
+        viewId: ViewId;
+    };
+    type Result = {
+        view: ComputedView | null;
+    };
+    const Req: RequestType<Params, Result, void>;
+    type Req = typeof Req;
+}
+export declare namespace FetchLayoutedModel {
+    type Res = {
+        model: LayoutedLikeC4Model | null;
+    };
+    const Req: RequestType0<Res, void>;
+    type Req = typeof Req;
+}
 /**
  * Request to layout a view.
  */
-export declare const layoutView: RequestType<{
-    viewId: ViewId;
-}, {
-    result: {
-        dot: string;
-        diagram: DiagramView;
-    } | null;
-}, void>;
-export type LayoutViewRequest = typeof layoutView;
+export declare namespace LayoutView {
+    type Params = {
+        viewId: ViewId;
+    };
+    type Res = {
+        result: {
+            dot: string;
+            diagram: DiagramView;
+        } | null;
+    };
+    const Req: RequestType<Params, Res, void>;
+    type Req = typeof Req;
+}
 /**
  * Request to layout all existing views.
  */
-export declare const validateLayout: RequestType<{}, {
-    result: {
-        uri: string;
-        viewId: ViewId;
-        message: string;
-        severity: DiagnosticSeverity;
-        range: {
-            start: Position;
-            end: Position;
-        };
-    }[] | null;
-}, void>;
-export type ValidateLayoutRequest = typeof validateLayout;
+export declare namespace ValidateLayout {
+    type Params = never;
+    type Res = {
+        result: {
+            uri: string;
+            viewId: ViewId;
+            message: string;
+            severity: DiagnosticSeverity;
+            range: {
+                start: Position;
+                end: Position;
+            };
+        }[] | null;
+    };
+    const Req: RequestType0<Res, void>;
+    type Req = typeof Req;
+}
 /**
  * Request to build documents.
  */
-export interface BuildDocumentsParams {
-    docs: DocumentUri[];
+export declare namespace BuildDocuments {
+    type Params = {
+        docs: DocumentUri[];
+    };
+    const Req: RequestType<Params, void, void>;
+    type Req = typeof Req;
 }
-export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
-export type BuildDocumentsRequest = typeof buildDocuments;
 /**
  * Request to locate an element, relation, deployment or view.
  */
-export type LocateParams = {
-    element: Fqn;
-    property?: string;
-} | {
-    relation: RelationId;
-} | {
-    deployment: Fqn;
-    property?: string;
-} | {
-    view: ViewId;
-};
-export declare const locate: RequestType<LocateParams, Location | null, void>;
-export type LocateRequest = typeof locate;
-export interface ChangeViewRequestParams {
-    viewId: ViewId;
-    change: ViewChange;
+export declare namespace Locate {
+    type Params = {
+        element: Fqn;
+        property?: string;
+    } | {
+        relation: RelationId;
+    } | {
+        deployment: Fqn;
+        property?: string;
+    } | {
+        view: ViewId;
+    };
+    type Res = Location | null;
+    const Req: RequestType<Params, Res, void>;
+    type Req = typeof Req;
+}
+export declare namespace ChangeView {
+    type Params = {
+        viewId: ViewId;
+        change: ViewChange;
+    };
+    type Res = Location | null;
+    const Req: RequestType<Params, Res, void>;
+    type Req = typeof Req;
 }
-export declare const changeView: RequestType<ChangeViewRequestParams, Location | null, void>;
-export type ChangeViewRequest = typeof changeView;

package/dist/protocol.js

@@ -1,16 +1,34 @@
 import { NotificationType, RequestType, RequestType0 } from "vscode-jsonrpc";
 export const onDidChangeModel = new NotificationType("likec4/onDidChangeModel");
-export const fetchModel = new RequestType0(
-  "likec4/fetchModel"
-);
-export const fetchComputedModel = new RequestType(
-  "likec4/fetchComputedModel"
-);
-export const computeView = new RequestType(
-  "likec4/computeView"
-);
-export const layoutView = new RequestType("likec4/layout-view");
-export const validateLayout = new RequestType("likec4/validate-layout");
-export const buildDocuments = new RequestType("likec4/build");
-export const locate = new RequestType("likec4/locate");
-export const changeView = new RequestType("likec4/change-view");
+export var FetchComputedModel;
+((FetchComputedModel2) => {
+  FetchComputedModel2.Req = new RequestType("likec4/fetchComputedModel");
+})(FetchComputedModel || (FetchComputedModel = {}));
+export var ComputeView;
+((ComputeView2) => {
+  ComputeView2.Req = new RequestType("likec4/computeView");
+})(ComputeView || (ComputeView = {}));
+export var FetchLayoutedModel;
+((FetchLayoutedModel2) => {
+  FetchLayoutedModel2.Req = new RequestType0("likec4/fetchLayoutedModel");
+})(FetchLayoutedModel || (FetchLayoutedModel = {}));
+export var LayoutView;
+((LayoutView2) => {
+  LayoutView2.Req = new RequestType("likec4/layout-view");
+})(LayoutView || (LayoutView = {}));
+export var ValidateLayout;
+((ValidateLayout2) => {
+  ValidateLayout2.Req = new RequestType0("likec4/validate-layout");
+})(ValidateLayout || (ValidateLayout = {}));
+export var BuildDocuments;
+((BuildDocuments2) => {
+  BuildDocuments2.Req = new RequestType("likec4/build");
+})(BuildDocuments || (BuildDocuments = {}));
+export var Locate;
+((Locate2) => {
+  Locate2.Req = new RequestType("likec4/locate");
+})(Locate || (Locate = {}));
+export var ChangeView;
+((ChangeView2) => {
+  ChangeView2.Req = new RequestType("likec4/change-view");
+})(ChangeView || (ChangeView = {}));

package/dist/views/likec4-views.js

@@ -1,5 +1,8 @@
+import { loggable } from "@likec4/log";
+import prettyMs from "pretty-ms";
 import { values } from "remeda";
-import { logError, logWarnError } from "../logger.js";
+import { logError, logger as rootLogger, logWarnError } from "../logger.js";
+const logger = rootLogger.getChild("Views");
 export class LikeC4Views {
   constructor(services) {
     this.services = services;
@@ -20,6 +23,7 @@ export class LikeC4Views {
     if (views.length === 0) {
       return [];
     }
+    logger.debug`layoutAll: ${views.length} views`;
     const results = [];
     const tasks = [];
     for (const view of views) {
@@ -41,26 +45,35 @@ export class LikeC4Views {
         results.push(task.value);
       }
     }
+    if (results.length !== views.length) {
+      logger.warn`layouted ${results.length} of ${views.length} views`;
+    } else if (results.length > 0) {
+      logger.debug`layouted all ${results.length} views`;
+    }
     return results;
   }
   async layoutView(viewId, cancelToken) {
     const model = await this.ModelBuilder.buildLikeC4Model(cancelToken);
     const view = model.findView(viewId)?.$view;
     if (!view) {
+      logger.warn`layoutView ${viewId} not found`;
       return null;
     }
     let cached = this.cache.get(view);
     if (cached) {
+      logger.debug`layout ${viewId} from cache`;
       return await Promise.resolve(cached);
     }
     try {
+      const start = performance.now();
       const result = await this.layouter.layout(view);
       this.viewsWithReportedErrors.delete(viewId);
       this.cache.set(view, result);
+      logger.debug(`layout {viewId} ready in ${prettyMs(performance.now() - start)}`, { viewId });
       return result;
     } catch (e) {
       if (!this.viewsWithReportedErrors.has(viewId)) {
-        const errMessage = e instanceof Error ? e.message : "" + e;
+        const errMessage = loggable(e);
         this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${errMessage}`);
         this.viewsWithReportedErrors.add(viewId);
         logError(e);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.24.1",
+  "version": "1.25.1",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -80,15 +80,13 @@
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
-  "dependencies": {
-    "@hpcc-js/wasm-graphviz": "1.7.0"
-  },
   "devDependencies": {
+    "@hpcc-js/wasm-graphviz": "1.7.0",
     "@msgpack/msgpack": "^3.1.0",
     "@smithy/util-base64": "^4.0.0",
-    "@types/node": "^20.17.17",
+    "@types/node": "^20.17.23",
     "@types/which": "^3.0.4",
-    "@vitest/coverage-v8": "^3.0.6",
+    "@vitest/coverage-v8": "^3.0.7",
     "esm-env": "^1.2.2",
     "fast-equals": "^5.2.2",
     "fdir": "^6.4.3",
@@ -98,25 +96,26 @@
     "langium-cli": "3.3.0",
     "natural-compare-lite": "^1.4.0",
     "p-debounce": "^4.0.0",
-    "remeda": "^2.20.2",
+    "pretty-ms": "^9.2.0",
+    "remeda": "^2.21.0",
     "strip-indent": "^4.0.0",
     "tsx": "~4.19.3",
-    "turbo": "^2.4.2",
+    "turbo": "^2.4.4",
     "type-fest": "4.34.1",
-    "typescript": "5.7.3",
+    "typescript": "5.8.2",
     "ufo": "^1.5.4",
     "unbuild": "^3.3.1",
-    "vitest": "^3.0.6",
+    "vitest": "^3.0.7",
     "vscode-jsonrpc": "8.2.0",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-types": "3.17.5",
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
-    "@likec4/core": "1.24.1",
-    "@likec4/icons": "1.24.1",
-    "@likec4/layouts": "1.24.1",
-    "@likec4/log": "1.24.1",
-    "@likec4/tsconfig": "1.24.1"
+    "@likec4/core": "1.25.1",
+    "@likec4/icons": "1.25.1",
+    "@likec4/layouts": "1.25.1",
+    "@likec4/log": "1.25.1",
+    "@likec4/tsconfig": "1.25.1"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",