@likec4/language-server 1.20.1 → 1.20.2

package/README.md

@@ -3,3 +3,22 @@
 [docs](https://likec4.dev/) | [playground](https://playground.likec4.dev/) | [demo](https://template.likec4.dev/view/cloud)
 
 Language Server Protocol (LSP) based on [languim](https://github.com/languim/languim) library.
+
+## Usage
+
+```bash
+npm install -g @likec4/language-server
+likec4-language-server --stdio
+```
+
+Valid arguments:
+- `--node-ipc`
+- `--stdio`
+- `--socket={number}`
+
+### Usage in code
+
+```js
+import { startLanguageServer } from '@likec4/language-server/bundled';
+startLanguageServer();
+```

package/bin/likec4-language-server.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { startLanguageServer } from '../dist/bundled.mjs'
+
+startLanguageServer()

package/dist/LikeC4FileSystem.js

@@ -1,26 +1,26 @@
 import { fdir } from "fdir";
 import { URI } from "langium";
 import { NodeFileSystemProvider } from "langium/node";
-import { stat } from "node:fs/promises";
+import { LikeC4LanguageMetaData } from "./generated/module.js";
 import { logger } from "./logger.js";
 export const LikeC4FileSystem = {
   fileSystemProvider: () => new SymLinkTraversingFileSystemProvider()
 };
+const hasExtension = (path) => LikeC4LanguageMetaData.fileExtensions.some((ext) => path.endsWith(ext));
 class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
   async readDirectory(folderPath) {
-    const crawled = await new fdir().withSymlinks().withFullPaths().crawl(folderPath.fsPath).withPromise();
     const entries = [];
-    for (const path of crawled) {
-      try {
-        const stats = await stat(path);
+    try {
+      const crawled = await new fdir().withSymlinks().withFullPaths().filter(hasExtension).crawl(folderPath.fsPath).withPromise();
+      for (const path of crawled) {
         entries.push({
-          isFile: stats.isFile(),
-          isDirectory: stats.isDirectory(),
+          isFile: true,
+          isDirectory: false,
           uri: URI.file(path)
         });
-      } catch (error) {
-        logger.error(error);
       }
+    } catch (error) {
+      logger.error(error);
     }
     return entries;
   }

package/dist/Rpc.d.ts

@@ -1,9 +1,7 @@
 import type { LikeC4Services } from './module';
-import { Disposable } from 'langium';
-export declare class Rpc implements Disposable {
+import { ADisposable } from './utils';
+export declare class Rpc extends ADisposable {
     private services;
-    private disposables;
     constructor(services: LikeC4Services);
     init(): void;
-    dispose(): void;
 }

package/dist/Rpc.js

@@ -1,5 +1,5 @@
-import { debounce } from "remeda";
-import { logError, logger } from "./logger.js";
+import { funnel } from "remeda";
+import { logger } from "./logger.js";
 import { nonexhaustive } from "@likec4/core";
 import { Disposable, interruptAndCheck, URI, UriUtils } from "langium";
 import { isLikeC4LangiumDocument } from "./ast.js";
@@ -14,11 +14,12 @@ import {
   locate,
   onDidChangeModel
 } from "./protocol.js";
-export class Rpc {
+import { ADisposable } from "./utils/index.js";
+export class Rpc extends ADisposable {
   constructor(services) {
+    super();
     this.services = services;
   }
-  disposables = [];
   init() {
     const modelBuilder = this.services.likec4.ModelBuilder;
     const modelLocator = this.services.likec4.ModelLocator;
@@ -32,28 +33,26 @@ export class Rpc {
     logger.info(`[ServerRpc] init`);
     const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
     const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
-    const notifyModelParsed = debounce(
+    const notifyModelParsed = funnel(
       () => {
         connection.sendNotification(onDidChangeModel, "").catch((e) => {
-          logger.error(`[ServerRpc] error sending onDidChangeModel: ${e}`);
+          logger.warn(`[ServerRpc] error sending onDidChangeModel: ${e}`);
           return Promise.resolve();
         });
       },
       {
-        timing: "trailing",
-        waitMs: 300,
-        maxWaitMs: 1e3
+        minQuietPeriodMs: 250,
+        maxBurstDurationMs: 1e3,
+        minGapMs: 200
       }
     );
     let isFirstBuild = true;
-    this.disposables.push(
-      Disposable.create(() => {
-        notifyModelParsed.cancel();
-      }),
+    this.onDispose(
       modelBuilder.onModelParsed(() => notifyModelParsed.call()),
       connection.onRequest(fetchComputedModel, async ({ cleanCaches }, cancelToken) => {
         if (cleanCaches) {
           this.services.WorkspaceCache.clear();
+          this.services.DocumentCache.clear();
         }
         const model = await modelBuilder.buildComputedModel(cancelToken);
         return { model };
@@ -94,39 +93,31 @@ export class Rpc {
               }
             })
           );
-          await interruptAndCheck(cancelToken);
         }
         isFirstBuild = false;
+        await interruptAndCheck(cancelToken);
         await DocumentBuilder.update(changed, deleted, cancelToken);
       }),
       connection.onRequest(locate, (params) => {
-        if ("element" in params) {
-          return modelLocator.locateElement(params.element, params.property ?? "name");
-        }
-        if ("relation" in params) {
-          return modelLocator.locateRelation(params.relation);
-        }
-        if ("view" in params) {
-          return modelLocator.locateView(params.view);
-        }
-        if ("deployment" in params) {
-          return modelLocator.locateDeploymentElement(params.deployment, params.property ?? "name");
+        switch (true) {
+          case "element" in params:
+            return modelLocator.locateElement(params.element, params.property ?? "name");
+          case "relation" in params:
+            return modelLocator.locateRelation(params.relation);
+          case "view" in params:
+            return modelLocator.locateView(params.view);
+          case "deployment" in params:
+            return modelLocator.locateDeploymentElement(params.deployment, params.property ?? "name");
+          default:
+            nonexhaustive(params);
         }
-        nonexhaustive(params);
       }),
       connection.onRequest(changeView, async (request, _cancelToken) => {
         return await modelEditor.applyChange(request);
+      }),
+      Disposable.create(() => {
+        notifyModelParsed.cancel();
       })
     );
   }
-  dispose() {
-    let item;
-    while (item = this.disposables.pop()) {
-      try {
-        item.dispose();
-      } catch (e) {
-        logError(e);
-      }
-    }
-  }
 }

package/dist/ast.d.ts

@@ -33,6 +33,7 @@ type ParsedElementStyle = {
     color?: c4.Color;
     border?: c4.BorderStyle;
     opacity?: number;
+    multiple?: boolean;
 };
 export interface ParsedAstSpecification {
     tags: Set<c4.Tag>;

package/dist/ast.js

@@ -1,6 +1,6 @@
 import { DefaultArrowType, DefaultLineStyle, DefaultRelationshipColor, LinkedList, nonexhaustive } from "@likec4/core";
 import { DocumentState } from "langium";
-import { clamp, isDefined, isNullish, isTruthy } from "remeda";
+import { clamp, isBoolean, isDefined, isNullish, isTruthy } from "remeda";
 import * as ast from "./generated/ast.js";
 import { LikeC4LanguageMetaData } from "./generated/module.js";
 import { elementRef } from "./utils/elementRef.js";
@@ -152,6 +152,10 @@ export function toElementStyle(props, isValid) {
         result.opacity = parseAstOpacityProperty(prop);
         break;
       }
+      case ast.isMultipleProperty(prop): {
+        result.multiple = isBoolean(prop.value) ? prop.value : false;
+        break;
+      }
       default:
         nonexhaustive(prop);
     }