@likec4/language-server 1.24.1 → 1.25.1

package/bin/likec4-language-server.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { startLanguageServer } from '.../dist/bundled.mjs'
+import { startLanguageServer } from '../dist/bundled.mjs'
 
 startLanguageServer().catch((e) => {
   console.error(e)

package/dist/Rpc.js

@@ -1,22 +1,23 @@
-import { filter, funnel, map, pipe } from "remeda";
-import { logger } from "./logger.js";
+import { filter, funnel, indexBy, map, pipe } from "remeda";
+import { logger as rootLogger } from "./logger.js";
 import { LikeC4Model, nonexhaustive } from "@likec4/core";
 import { Disposable, interruptAndCheck, URI, UriUtils } from "langium";
 import { DiagnosticSeverity } from "vscode-languageserver";
 import { isLikeC4LangiumDocument } from "./ast.js";
 import { isLikeC4Builtin } from "./likec4lib.js";
 import {
-  buildDocuments,
-  changeView,
-  computeView,
-  fetchComputedModel,
-  fetchModel,
-  layoutView,
-  locate,
+  BuildDocuments,
+  ChangeView,
+  ComputeView,
+  FetchComputedModel,
+  FetchLayoutedModel,
+  LayoutView,
+  Locate,
   onDidChangeModel,
-  validateLayout
+  ValidateLayout
 } from "./protocol.js";
 import { ADisposable } from "./utils/index.js";
+const logger = rootLogger.getChild("rpc");
 export class Rpc extends ADisposable {
   constructor(services) {
     super();
@@ -37,20 +38,24 @@ export class Rpc extends ADisposable {
     const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
     const notifyModelParsed = funnel(
       () => {
+        logger.debug`sendNotification ${"onDidChangeModel"}`;
         connection.sendNotification(onDidChangeModel, "").catch((e) => {
           logger.warn(`[ServerRpc] error sending onDidChangeModel: ${e}`);
           return Promise.resolve();
         });
       },
       {
-        triggerAt: "both",
-        minGapMs: 350
+        triggerAt: "end",
+        minQuietPeriodMs: 150,
+        maxBurstDurationMs: 500,
+        minGapMs: 300
       }
     );
     let isFirstBuild = true;
     this.onDispose(
       modelBuilder.onModelParsed(() => notifyModelParsed.call()),
-      connection.onRequest(fetchComputedModel, async ({ cleanCaches }, cancelToken) => {
+      connection.onRequest(FetchComputedModel.Req, async ({ cleanCaches }, cancelToken) => {
+        logger.debug`received request ${"fetchComputedModel"}`;
         if (cleanCaches) {
           const all = LangiumDocuments.all.map((d) => d.uri).toArray();
           await DocumentBuilder.update(all, [], cancelToken);
@@ -61,24 +66,35 @@ export class Rpc extends ADisposable {
         }
         return { model: null };
       }),
-      connection.onRequest(fetchModel, async (cancelToken) => {
-        const model = await modelBuilder.parseModel(cancelToken);
-        return { model };
-      }),
-      connection.onRequest(computeView, async ({ viewId }, cancelToken) => {
+      connection.onRequest(ComputeView.Req, async ({ viewId }, cancelToken) => {
         const view = await modelBuilder.computeView(viewId, cancelToken);
         return { view };
       }),
-      connection.onRequest(layoutView, async ({ viewId }, cancelToken) => {
+      connection.onRequest(FetchLayoutedModel.Req, async (cancelToken) => {
+        const model = await modelBuilder.parseModel(cancelToken);
+        if (model === null) {
+          return { model: null };
+        }
+        const diagrams = await views.diagrams();
+        return {
+          model: {
+            ...model,
+            __: "layouted",
+            views: indexBy(diagrams, (d) => d.id)
+          }
+        };
+      }),
+      connection.onRequest(LayoutView.Req, async ({ viewId }, cancelToken) => {
+        logger.debug`received request ${"layoutView"} of ${viewId}`;
         const result = await views.layoutView(viewId, cancelToken);
         return { result };
       }),
-      connection.onRequest(validateLayout, async (_, cancelToken) => {
+      connection.onRequest(ValidateLayout.Req, async (cancelToken) => {
         const layouts = await views.layoutAllViews(cancelToken);
         const result = reportLayoutDrift(layouts.map((l) => l.diagram));
         return { result };
       }),
-      connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
+      connection.onRequest(BuildDocuments.Req, async ({ docs }, cancelToken) => {
         const changed = docs.map((d) => URI.parse(d));
         const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));
         const deleted = LangiumDocuments.all.toArray().filter((d) => !isLikeC4Builtin(d.uri) && isLikeC4LangiumDocument(d) && notChanged(d.uri)).map((d) => d.uri);
@@ -107,7 +123,7 @@ export class Rpc extends ADisposable {
         await interruptAndCheck(cancelToken);
         await DocumentBuilder.update(changed, deleted, cancelToken);
       }),
-      connection.onRequest(locate, (params) => {
+      connection.onRequest(Locate.Req, (params) => {
         switch (true) {
           case "element" in params:
             return modelLocator.locateElement(params.element, params.property ?? "name");
@@ -121,7 +137,8 @@ export class Rpc extends ADisposable {
             nonexhaustive(params);
         }
       }),
-      connection.onRequest(changeView, async (request, _cancelToken) => {
+      connection.onRequest(ChangeView.Req, async (request, _cancelToken) => {
+        logger.debug`received request ${"changeView"} of ${request.viewId}`;
         return await modelEditor.applyChange(request);
       }),
       Disposable.create(() => {