@likec4/language-server 1.19.0 → 1.19.1

package/dist/validation/dynamic-view-step.js

@@ -1,33 +1,29 @@
 import { isAncestor } from "@likec4/core";
-import { logError } from "../logger.js";
 import { elementRef } from "../utils/elementRef.js";
+import { tryOrLog } from "./_shared.js";
 export const dynamicViewStep = (services) => {
   const fqnIndex = services.likec4.FqnIndex;
-  return (el, accept) => {
-    try {
-      const sourceEl = elementRef(el.source);
-      const source = sourceEl && fqnIndex.getFqn(sourceEl);
-      if (!source) {
-        accept("error", "Source not found (not parsed/indexed yet)", {
-          node: el,
-          property: "source"
-        });
-      }
-      const targetEl = elementRef(el.target);
-      const target = targetEl && fqnIndex.getFqn(targetEl);
-      if (!target) {
-        accept("error", "Target not found (not parsed/indexed yet)", {
-          node: el,
-          property: "target"
-        });
-      }
-      if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
-        accept("error", "Invalid parent-child relationship", {
-          node: el
-        });
-      }
-    } catch (e) {
-      logError(e);
+  return tryOrLog((el, accept) => {
+    const sourceEl = elementRef(el.source);
+    const source = sourceEl && fqnIndex.getFqn(sourceEl);
+    if (!source) {
+      accept("error", "Source not found (not parsed/indexed yet)", {
+        node: el,
+        property: "source"
+      });
     }
-  };
+    const targetEl = elementRef(el.target);
+    const target = targetEl && fqnIndex.getFqn(targetEl);
+    if (!target) {
+      accept("error", "Target not found (not parsed/indexed yet)", {
+        node: el,
+        property: "target"
+      });
+    }
+    if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
+      accept("error", "Invalid parent-child relationship", {
+        node: el
+      });
+    }
+  });
 };

package/dist/validation/property-checks.js

@@ -1,7 +1,8 @@
 import { AstUtils } from "langium";
 import { ast } from "../ast.js";
+import { tryOrLog } from "./_shared.js";
 export const opacityPropertyRuleChecks = (_) => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const opacity = parseFloat(node.value);
     if (isNaN(opacity) || opacity < 0 || opacity > 100) {
       accept("warning", `Value ignored, must be between 0% and 100%`, {
@@ -9,7 +10,7 @@ export const opacityPropertyRuleChecks = (_) => {
         property: "value"
       });
     }
-  };
+  });
 };
 export const iconPropertyRuleChecks = (_) => {
   return (node, accept) => {

package/dist/validation/specification.js

@@ -2,34 +2,34 @@ import { AstUtils } from "langium";
 import { ast } from "../ast.js";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
 export const specificationRuleChecks = (_) => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept("warning", `Prefer one specification per document`, {
         node,
         property: "name"
       });
     }
-  };
+  });
 };
 export const modelRuleChecks = (_) => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept("warning", `Prefer one model per document`, {
         node,
         property: "name"
       });
     }
-  };
+  });
 };
 export const globalsChecks = (_) => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept("warning", `Prefer one global block per document`, {
         node,
         property: "name"
       });
     }
-  };
+  });
 };
 export const elementKindChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
@@ -63,7 +63,7 @@ export const elementKindChecks = (services) => {
 };
 export const tagChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const tagname = "#" + node.name;
     const sameTag = index.allElements(ast.Tag).filter((n) => n.name === tagname && n.node !== node).head();
     if (sameTag) {
@@ -88,11 +88,11 @@ export const tagChecks = (services) => {
         }
       );
     }
-  };
+  });
 };
 export const relationshipChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (RESERVED_WORDS.includes(node.name)) {
       accept("error", `Reserved word: ${node.name}`, {
         node,
@@ -106,11 +106,11 @@ export const relationshipChecks = (services) => {
         property: "name"
       });
     }
-  };
+  });
 };
 export const globalPredicateChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const predicateGroups = index.allElements(ast.GlobalPredicateGroup);
     const dynamicPredicateGroups = index.allElements(ast.GlobalDynamicPredicateGroup);
     const sameName = predicateGroups.concat(dynamicPredicateGroups).filter((s) => s.name === node.name).limit(2).count();
@@ -120,11 +120,11 @@ export const globalPredicateChecks = (services) => {
         property: "name"
       });
     }
-  };
+  });
 };
 export const globalStyleIdChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const sameName = index.allElements(ast.GlobalStyleId).filter((s) => s.name === node.name).limit(2).count();
     if (sameName > 1) {
       accept("error", `Duplicate GlobalStyleId name '${node.name}'`, {
@@ -132,5 +132,5 @@ export const globalStyleIdChecks = (services) => {
         property: "name"
       });
     }
-  };
+  });
 };

package/dist/validation/view-predicates/element-with.js

@@ -1,8 +1,9 @@
 import { nonexhaustive } from "@likec4/core";
 import { AstUtils } from "langium";
 import { ast } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
 export const elementPredicateWithChecks = (_services) => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate);
     if (ast.isExcludePredicate(container)) {
       accept("error", 'Invalid usage inside "exclude"', {
@@ -26,5 +27,5 @@ export const elementPredicateWithChecks = (_services) => {
       default:
         nonexhaustive(subject);
     }
-  };
+  });
 };

package/dist/validation/view-predicates/expanded-element.js

@@ -1,11 +1,12 @@
 import { AstUtils } from "langium";
 import { ast } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
 export const expandElementExprChecks = (_services) => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (AstUtils.hasContainerOfType(el, ast.isRelationExpression)) {
       accept("warning", `Redundant usage, expand predicate resolves parent element only when used in relations`, {
         node: el
       });
     }
-  };
+  });
 };

package/dist/validation/view-predicates/incoming.js

@@ -1,8 +1,9 @@
 import { AstUtils } from "langium";
 import { isNullish } from "remeda";
 import { ast } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
 export const incomingExpressionChecks = (_services) => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (ast.isWildcardExpression(el.to) && !ast.isInOutRelationExpression(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView);
       if (isNullish(view?.viewOf)) {
@@ -11,5 +12,5 @@ export const incomingExpressionChecks = (_services) => {
         });
       }
     }
-  };
+  });
 };

package/dist/validation/view-predicates/outgoing.js

@@ -1,8 +1,9 @@
 import { AstUtils } from "langium";
 import { isNullish } from "remeda";
 import { ast } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
 export const outgoingExpressionChecks = (_services) => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (ast.isWildcardExpression(el.from) && !ast.isDirectedRelationExpression(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView);
       if (isNullish(view?.viewOf)) {
@@ -11,5 +12,5 @@ export const outgoingExpressionChecks = (_services) => {
         });
       }
     }
-  };
+  });
 };

package/dist/validation/view-predicates/relation-with.js

@@ -1,12 +1,13 @@
 import { AstUtils } from "langium";
 import { ast } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
 export const relationPredicateWithChecks = (_services) => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate);
     if (ast.isExcludePredicate(container)) {
       accept("error", 'Invalid usage inside "exclude"', {
         node: el
       });
     }
-  };
+  });
 };

package/dist/validation/view.js

@@ -1,8 +1,8 @@
 import { ast } from "../ast.js";
-import { RESERVED_WORDS } from "./_shared.js";
+import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
 export const viewChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (!el.name) {
       return;
     }
@@ -19,5 +19,5 @@ export const viewChecks = (services) => {
         property: "name"
       });
     }
-  };
+  });
 };

package/dist/views/configurable-layouter.d.ts

@@ -0,0 +1,7 @@
+import { GraphvizLayouter } from '@likec4/layouts';
+import type { LikeC4Services } from '../module';
+export declare const ConfigurableLayouter: {
+    likec4: {
+        Layouter(services: LikeC4Services): GraphvizLayouter;
+    };
+};

package/dist/views/configurable-layouter.js

@@ -0,0 +1,55 @@
+import { GraphvizLayouter, GraphvizWasmAdapter } from "@likec4/layouts";
+import { GraphvizBinaryAdapter } from "@likec4/layouts/graphviz/binary";
+import { isEmpty } from "remeda";
+import which from "which";
+import { logger } from "../logger.js";
+function graphvizBinPath() {
+  try {
+    return which.sync("dot");
+  } catch (error) {
+    logger.error("Error checking for native Graphviz:", error);
+    return null;
+  }
+}
+export const ConfigurableLayouter = {
+  likec4: {
+    Layouter(services) {
+      logger.debug("Creating ConfigurableLayouter");
+      const wasmAdapter = new GraphvizWasmAdapter();
+      const layouter = new GraphvizLayouter(wasmAdapter);
+      const langId = services.LanguageMetaData.languageId;
+      services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
+        logger.debug("Configuration update", update);
+        if (update.section === langId) {
+          try {
+            const { mode, path } = update.configuration.graphviz ?? {
+              mode: "wasm",
+              path: ""
+            };
+            if (mode === "wasm") {
+              layouter.changePort(wasmAdapter);
+              logger.info("use graphviz wasm");
+              return;
+            }
+            let binaryPath = isEmpty(path) ? graphvizBinPath() : path;
+            if (binaryPath === null) {
+              layouter.changePort(wasmAdapter);
+              logger.warn(`No Graphviz binaries found on PATH, use graphviz wasm`);
+              services.shared.lsp.Connection?.window.showWarningMessage(
+                "No Graphviz binaries found on PATH, set path to binaries in settings."
+              );
+              return;
+            }
+            layouter.changePort(new GraphvizBinaryAdapter(binaryPath));
+            logger.info(`use graphviz binary: ${binaryPath}`);
+          } catch (error) {
+            logger.error("Failed to update configuration", error);
+          }
+          return;
+        }
+        logger.warn("Unexpected configuration update", update);
+      });
+      return layouter;
+    }
+  }
+};

package/dist/views/index.d.ts

@@ -0,0 +1 @@
+export { LikeC4Views } from './likec4-views';

package/dist/views/index.js

@@ -0,0 +1 @@
+export { LikeC4Views } from "./likec4-views.js";

package/dist/views/likec4-views.d.ts

@@ -0,0 +1,26 @@
+import type { ComputedView, DiagramView, OverviewGraph, ViewId } from '@likec4/core';
+import { type Cancellation } from 'langium';
+import type { LikeC4Services } from '../module';
+export type GraphvizOut = {
+    dot: string;
+    diagram: DiagramView;
+};
+type GraphvizSvgOut = {
+    id: ViewId;
+    dot: string;
+    svg: string;
+};
+export declare class LikeC4Views {
+    private services;
+    private cache;
+    private viewsWithReportedErrors;
+    constructor(services: LikeC4Services);
+    private get layouter();
+    computedViews(cancelToken?: Cancellation.CancellationToken): Promise<ComputedView[]>;
+    layoutAllViews(cancelToken?: Cancellation.CancellationToken): Promise<Array<Readonly<GraphvizOut>>>;
+    layoutView(viewId: ViewId, cancelToken?: Cancellation.CancellationToken): Promise<GraphvizOut | null>;
+    diagrams(): Promise<Array<DiagramView>>;
+    viewsAsGraphvizOut(): Promise<Array<GraphvizSvgOut>>;
+    overviewGraph(): Promise<OverviewGraph>;
+}
+export {};

package/dist/views/likec4-views.js

@@ -0,0 +1,113 @@
+import { values } from "remeda";
+import { logger, logWarnError } from "../logger.js";
+export class LikeC4Views {
+  constructor(services) {
+    this.services = services;
+  }
+  cache = /* @__PURE__ */ new WeakMap();
+  viewsWithReportedErrors = /* @__PURE__ */ new Set();
+  get layouter() {
+    return this.services.likec4.Layouter;
+  }
+  async computedViews(cancelToken) {
+    const model = await this.services.likec4.ModelBuilder.buildComputedModel(cancelToken);
+    return model ? values(model.views) : [];
+  }
+  async layoutAllViews(cancelToken) {
+    const views = await this.computedViews(cancelToken);
+    if (views.length === 0) {
+      return [];
+    }
+    const results = [];
+    const tasks = [];
+    for (const view of views) {
+      this.viewsWithReportedErrors.delete(view.id);
+      tasks.push(
+        this.layouter.layout(view).then((result) => {
+          this.cache.set(view, result);
+          return result;
+        }).catch((e) => {
+          this.cache.delete(view);
+          logWarnError(e);
+          return Promise.reject(e);
+        })
+      );
+    }
+    for (const task of await Promise.allSettled(tasks)) {
+      if (task.status === "fulfilled") {
+        results.push(task.value);
+      }
+    }
+    return results;
+  }
+  async layoutView(viewId, cancelToken) {
+    const model = await this.services.likec4.ModelBuilder.buildComputedModel(cancelToken);
+    if (!model) {
+      return null;
+    }
+    const view = model.views[viewId];
+    if (!view) {
+      return null;
+    }
+    let cached = this.cache.get(view);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const result = await this.layouter.layout(view);
+      this.viewsWithReportedErrors.delete(viewId);
+      this.cache.set(view, result);
+      return result;
+    } catch (e) {
+      if (!this.viewsWithReportedErrors.has(viewId)) {
+        const errMessage = e instanceof Error ? e.message : "" + e;
+        this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${errMessage}`);
+        this.viewsWithReportedErrors.add(viewId);
+      }
+      logger.error(e);
+      return Promise.reject(e);
+    }
+  }
+  async diagrams() {
+    const layouted = await this.layoutAllViews();
+    return layouted.map((l) => l.diagram);
+  }
+  async viewsAsGraphvizOut() {
+    const KEY = "All-LayoutedViews-DotWithSvg";
+    const cache = this.services.WorkspaceCache;
+    if (cache.has(KEY)) {
+      return await Promise.resolve(cache.get(KEY));
+    }
+    const views = await this.computedViews();
+    const tasks = views.map(async (view) => {
+      const { dot, svg } = await this.layouter.svg(view);
+      return {
+        id: view.id,
+        dot,
+        svg
+      };
+    });
+    const succeed = [];
+    const settledResult = await Promise.allSettled(tasks);
+    for (const result of settledResult) {
+      if (result.status === "fulfilled") {
+        succeed.push(result.value);
+      } else {
+        logWarnError(result.reason);
+      }
+    }
+    cache.set(KEY, succeed);
+    return succeed;
+  }
+  async overviewGraph() {
+    const KEY = "OverviewGraph";
+    const cache = this.services.WorkspaceCache;
+    if (cache.has(KEY)) {
+      return await Promise.resolve(cache.get(KEY));
+    }
+    const views = await this.computedViews();
+    const overviewGraph = await this.layouter.layoutOverviewGraph(views);
+    cache.set(KEY, overviewGraph);
+    return overviewGraph;
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -24,7 +24,7 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "development": "./src/index.ts",
+      "sources": "./src/index.ts",
       "node": {
         "types": "./dist/index.d.ts",
         "import": "./dist/index.js",
@@ -37,7 +37,7 @@
       }
     },
     "./likec4lib": {
-      "development": "./src/likec4lib.ts",
+      "sources": "./src/likec4lib.ts",
       "default": {
         "types": "./dist/likec4lib.d.ts",
         "import": "./dist/likec4lib.js",
@@ -45,7 +45,7 @@
       }
     },
     "./browser": {
-      "development": "./src/browser.ts",
+      "sources": "./src/browser.ts",
       "default": {
         "types": "./dist/browser.d.ts",
         "import": "./dist/browser.js",
@@ -53,7 +53,7 @@
       }
     },
     "./protocol": {
-      "development": "./src/protocol.ts",
+      "sources": "./src/protocol.ts",
       "default": {
         "types": "./dist/protocol.d.ts",
         "import": "./dist/protocol.js",
@@ -82,8 +82,9 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@likec4/core": "1.19.0",
-    "@likec4/log": "1.19.0",
+    "@likec4/core": "1.19.1",
+    "@likec4/layouts": "1.19.1",
+    "@likec4/log": "1.19.1",
     "@msgpack/msgpack": "^3.0.0-beta2",
     "@smithy/util-base64": "^3.0.0",
     "esm-env": "^1.2.1",
@@ -100,12 +101,14 @@
     "vscode-jsonrpc": "8.2.0",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-types": "3.17.5",
-    "vscode-uri": "3.0.8"
+    "vscode-uri": "3.0.8",
+    "which": "^4.0.0"
   },
   "devDependencies": {
-    "@likec4/icons": "1.19.0",
-    "@likec4/tsconfig": "1.19.0",
+    "@likec4/icons": "1.19.1",
+    "@likec4/tsconfig": "1.19.1",
     "@types/node": "^20.17.7",
+    "@types/which": "^3.0.4",
     "@vitest/coverage-v8": "^2.1.8",
     "execa": "^9.3.1",
     "langium-cli": "3.3.0",

package/src/Rpc.ts

@@ -12,8 +12,9 @@ import {
   computeView,
   fetchComputedModel,
   fetchModel,
+  layoutView,
   locate,
-  onDidChangeModel
+  onDidChangeModel,
 } from './protocol'
 
 export class Rpc implements Disposable {
@@ -25,6 +26,7 @@ export class Rpc implements Disposable {
     const modelBuilder = this.services.likec4.ModelBuilder
     const modelLocator = this.services.likec4.ModelLocator
     const modelEditor = this.services.likec4.ModelChanges
+    const views = this.services.likec4.Views
     const connection = this.services.shared.lsp.Connection
     if (!connection) {
       logger.info(`[ServerRpc] no connection, not initializing`)
@@ -44,8 +46,8 @@ export class Rpc implements Disposable {
       {
         timing: 'trailing',
         waitMs: 300,
-        maxWaitMs: 1000
-      }
+        maxWaitMs: 1000,
+      },
     )
 
     let isFirstBuild = true
@@ -70,6 +72,10 @@ export class Rpc implements Disposable {
         const view = await modelBuilder.computeView(viewId, cancelToken)
         return { view }
       }),
+      connection.onRequest(layoutView, async ({ viewId }, cancelToken) => {
+        const result = await views.layoutView(viewId, cancelToken)
+        return { result }
+      }),
       connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
         const changed = docs.map(d => URI.parse(d))
         const notChanged = (uri: URI) => changed.every(c => !UriUtils.equals(c, uri))
@@ -80,7 +86,7 @@ export class Rpc implements Disposable {
         logger.debug(
           `[ServerRpc] received request to build:
   changed (total ${changed.length}):${docs.map(d => '\n    - ' + d).join('')}
-  deleted (total ${deleted.length}):${deleted.map(d => '\n    - ' + d.toString()).join('\n')}`
+  deleted (total ${deleted.length}):${deleted.map(d => '\n    - ' + d.toString()).join('\n')}`,
         )
 
         if (!isFirstBuild && (changed.length + deleted.length) > 0) {
@@ -91,13 +97,13 @@ export class Rpc implements Disposable {
               try {
                 await connection.sendDiagnostics({
                   uri,
-                  diagnostics: []
+                  diagnostics: [],
                 })
               } catch (e) {
                 // Ignore
                 logger.warn(`error clearing diagnostics for ${uri}: ${e}`)
               }
-            })
+            }),
           )
           await interruptAndCheck(cancelToken)
         }
@@ -121,7 +127,7 @@ export class Rpc implements Disposable {
       }),
       connection.onRequest(changeView, async (request, _cancelToken) => {
         return await modelEditor.applyChange(request)
-      })
+      }),
     )
   }
 

package/src/browser.ts

@@ -7,6 +7,7 @@ export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4Mode
 
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module'
 export type { LikeC4Services, LikeC4SharedServices } from './module'
+export type { LikeC4Views } from './views'
 
 // This is an example copied as is from here:
 // https://github.com/microsoft/vscode-extension-samples/blob/main/lsp-web-extension-sample/server/src/browserServerMain.ts