@likec4/language-server 1.18.0 → 1.19.1

package/dist/view-utils/assignNavigateTo.d.ts

@@ -0,0 +1,2 @@
+import { ComputedView } from '@likec4/core';
+export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;

package/dist/view-utils/assignNavigateTo.js

@@ -0,0 +1,25 @@
+import { ComputedNode, ComputedView } from "@likec4/core";
+import { find, isNullish } from "remeda";
+export function assignNavigateTo(views) {
+  const allElementViews = /* @__PURE__ */ new Map();
+  for (const v of views) {
+    if (ComputedView.isElement(v) && v.viewOf && isNullish(v.extends)) {
+      const viewsOf = allElementViews.get(v.viewOf) ?? [];
+      viewsOf.push(v.id);
+      allElementViews.set(v.viewOf, viewsOf);
+    }
+  }
+  for (const { id, nodes } of views) {
+    for (const node of nodes) {
+      const modelRef = ComputedNode.modelRef(node);
+      if (node.navigateTo || !modelRef) {
+        continue;
+      }
+      const navigateTo = find(allElementViews.get(modelRef) ?? [], (v) => v !== id);
+      if (navigateTo) {
+        node.navigateTo = navigateTo;
+      }
+    }
+  }
+  return views;
+}

package/dist/view-utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './assignNavigateTo';
+export * from './resolve-relative-paths';

package/dist/view-utils/index.js

@@ -0,0 +1,2 @@
+export * from "./assignNavigateTo.js";
+export * from "./resolve-relative-paths.js";

package/dist/view-utils/manual-layout.d.ts

@@ -0,0 +1,7 @@
+import type * as c4 from '@likec4/core';
+import { type ViewManualLayout } from '@likec4/core';
+import type { ast } from '../ast';
+export declare function serializeToComment(layout: ViewManualLayout): string;
+export declare function hasManualLayout(comment: string): boolean;
+export declare function deserializeFromComment(comment: string): ViewManualLayout;
+export declare function parseViewManualLayout(node: ast.LikeC4View): c4.ViewManualLayout | undefined;

package/dist/view-utils/manual-layout.js

@@ -0,0 +1,99 @@
+import { isAutoLayoutDirection } from "@likec4/core";
+import { decode, encode } from "@msgpack/msgpack";
+import { fromBase64, toBase64 } from "@smithy/util-base64";
+import { AstUtils, CstUtils } from "langium";
+import { mapValues } from "remeda";
+import { logger } from "../logger.js";
+const { getDocument } = AstUtils;
+function pack({
+  nodes,
+  edges,
+  ...rest
+}) {
+  return {
+    ...rest,
+    nodes: mapValues(nodes, ({ x, y, width, height, isCompound, ...n }) => ({
+      ...n,
+      b: [x, y, width, height],
+      c: isCompound
+    })),
+    edges: mapValues(edges, ({ points, controlPoints, labelBBox, dotpos, ...e }) => ({
+      ...!!controlPoints && { cp: controlPoints },
+      ...!!labelBBox && { l: labelBBox },
+      ...!!dotpos && { dp: dotpos },
+      ...e,
+      p: points
+    }))
+  };
+}
+function unpack({
+  nodes,
+  edges,
+  autoLayout,
+  ...rest
+}) {
+  return {
+    ...rest,
+    /// Try to parse the old format for backward compatibility
+    autoLayout: isAutoLayoutDirection(autoLayout) ? { direction: autoLayout } : autoLayout,
+    nodes: mapValues(nodes, ({ b, c, ...n }) => ({
+      x: b[0],
+      y: b[1],
+      width: b[2],
+      height: b[3],
+      isCompound: c,
+      ...n
+    })),
+    edges: mapValues(edges, ({ p, cp, l, dp, ...e }) => ({
+      ...!!cp && { controlPoints: cp },
+      ...!!l && { labelBBox: l },
+      ...!!dp && { dotpos: dp },
+      ...e,
+      points: p
+    }))
+  };
+}
+const MAX_LINE_LENGTH = 500;
+export function serializeToComment(layout) {
+  const bytes = encode(pack(layout));
+  const base64 = toBase64(bytes);
+  const lines = [];
+  let offset = 0;
+  while (offset < base64.length) {
+    lines.push(" * " + base64.slice(offset, Math.min(offset + MAX_LINE_LENGTH, base64.length)));
+    offset += MAX_LINE_LENGTH;
+  }
+  lines.unshift(
+    "/**",
+    " * @likec4-generated(v1)"
+  );
+  lines.push(" */");
+  return lines.join("\n");
+}
+export function hasManualLayout(comment) {
+  return comment.includes("@likec4-generated");
+}
+export function deserializeFromComment(comment) {
+  if (!hasManualLayout(comment)) {
+    throw new Error(`Not a likec4-generated comment: ${comment}`);
+  }
+  const b64 = comment.trim().split("\n").filter((l) => !l.includes("**") && !l.includes("@likec4-") && !l.includes("*/")).map((l) => l.replaceAll("*", "").trim()).join("");
+  const decodedb64 = fromBase64(b64);
+  return unpack(decode(decodedb64));
+}
+export function parseViewManualLayout(node) {
+  const commentNode = CstUtils.findCommentNode(node.$cstNode, ["BLOCK_COMMENT"]);
+  if (!commentNode || !hasManualLayout(commentNode.text)) {
+    return void 0;
+  }
+  try {
+    return deserializeFromComment(commentNode.text);
+  } catch (e) {
+    const doc = getDocument(node);
+    logger.warn(e);
+    logger.warn(
+      `Ignoring manual layout of "${node.name ?? "unnamed"}" at ${doc.uri.fsPath}:${1 + (commentNode.range.start.line || 0)}`
+    );
+    return void 0;
+  }
+}

package/dist/view-utils/resolve-relative-paths.d.ts

@@ -0,0 +1,2 @@
+import type { LikeC4View } from '@likec4/core';
+export declare function resolveRelativePaths(views: LikeC4View[]): LikeC4View[];

package/dist/view-utils/resolve-relative-paths.js

@@ -0,0 +1,78 @@
+import { compareNatural, invariant } from "@likec4/core";
+import { filter, hasAtLeast, isTruthy, map, pipe, unique } from "remeda";
+import { parsePath } from "ufo";
+function commonAncestorPath(views, sep = "/") {
+  const uniqURIs = pipe(
+    views,
+    map((v) => v.docUri),
+    filter(isTruthy),
+    unique()
+  );
+  if (uniqURIs.length === 0) return "";
+  if (uniqURIs.length === 1) {
+    const parts2 = parsePath(uniqURIs[0]).pathname.split(sep);
+    if (parts2.length <= 1) return sep;
+    parts2.pop();
+    return parts2.join(sep) + sep;
+  }
+  invariant(hasAtLeast(uniqURIs, 2), "Expected at least 2 unique URIs");
+  const [baseUri, ...tail] = uniqURIs;
+  const parts = parsePath(baseUri).pathname.split(sep);
+  let endOfPrefix = parts.length;
+  for (const uri of tail) {
+    if (uri === baseUri) {
+      continue;
+    }
+    const compare = parsePath(uri).pathname.split(sep);
+    for (let i = 0; i < endOfPrefix; i++) {
+      if (compare[i] !== parts[i]) {
+        endOfPrefix = i;
+      }
+    }
+    if (endOfPrefix === 0) return "";
+  }
+  const prefix = parts.slice(0, endOfPrefix).join(sep);
+  return prefix.endsWith(sep) ? prefix : prefix + sep;
+}
+export function resolveRelativePaths(views) {
+  const sep = "/";
+  const commonPrefix = commonAncestorPath(views, sep);
+  return views.map((view) => {
+    if (!view.docUri) {
+      return {
+        view,
+        parts: []
+      };
+    }
+    let path = parsePath(view.docUri).pathname;
+    if (commonPrefix.length > 0) {
+      invariant(
+        path.startsWith(commonPrefix),
+        `Expect path "${path}" to start with common prefix: "${commonPrefix}"`
+      );
+      path = path.slice(commonPrefix.length);
+    } else {
+      path = path.includes(sep) ? path.slice(path.lastIndexOf(sep) + 1) : path;
+    }
+    return {
+      view,
+      parts: path.split(sep)
+    };
+  }).sort((a, b) => {
+    if (a.parts.length !== b.parts.length) {
+      return a.parts.length - b.parts.length;
+    }
+    for (let i = 0; i < a.parts.length; i++) {
+      const compare = compareNatural(a.parts[i], b.parts[i]);
+      if (compare !== 0) {
+        return compare;
+      }
+    }
+    return compareNatural(a.view.title ?? a.view.id, b.view.title ?? b.view.id);
+  }).map(({ parts, view }) => {
+    return {
+      ...view,
+      relativePath: parts.join(sep)
+    };
+  });
+}

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.18.0",
+  "version": "1.19.1",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -24,65 +24,46 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "browser": {
-        "types": "./dist/browser.d.ts",
-        "import": "./dist/browser.mjs",
-        "require": "./dist/browser.cjs"
+      "sources": "./src/index.ts",
+      "node": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
       },
       "default": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.mjs",
-        "require": "./dist/index.cjs"
+        "types": "./dist/browser.d.ts",
+        "import": "./dist/browser.js",
+        "default": "./dist/browser.js"
       }
     },
     "./likec4lib": {
-      "types": "./dist/likec4lib.d.ts",
-      "import": "./dist/likec4lib.mjs",
-      "require": "./dist/likec4lib.cjs"
+      "sources": "./src/likec4lib.ts",
+      "default": {
+        "types": "./dist/likec4lib.d.ts",
+        "import": "./dist/likec4lib.js",
+        "default": "./dist/likec4lib.js"
+      }
     },
     "./browser": {
-      "types": "./dist/browser.d.ts",
-      "import": "./dist/browser.mjs",
-      "require": "./dist/browser.cjs"
+      "sources": "./src/browser.ts",
+      "default": {
+        "types": "./dist/browser.d.ts",
+        "import": "./dist/browser.js",
+        "default": "./dist/browser.js"
+      }
     },
     "./protocol": {
-      "types": "./dist/protocol.d.ts",
-      "import": "./dist/protocol.mjs",
-      "require": "./dist/protocol.cjs"
+      "sources": "./src/protocol.ts",
+      "default": {
+        "types": "./dist/protocol.d.ts",
+        "import": "./dist/protocol.js",
+        "default": "./dist/protocol.js"
+      }
     }
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "exports": {
-      ".": {
-        "browser": {
-          "types": "./dist/browser.d.ts",
-          "import": "./dist/browser.mjs",
-          "require": "./dist/browser.cjs"
-        },
-        "default": {
-          "types": "./dist/index.d.ts",
-          "import": "./dist/index.mjs",
-          "require": "./dist/index.cjs"
-        }
-      },
-      "./likec4lib": {
-        "types": "./dist/likec4lib.d.ts",
-        "import": "./dist/likec4lib.mjs",
-        "require": "./dist/likec4lib.cjs"
-      },
-      "./browser": {
-        "types": "./dist/browser.d.ts",
-        "import": "./dist/browser.mjs",
-        "require": "./dist/browser.cjs"
-      },
-      "./protocol": {
-        "types": "./dist/protocol.d.ts",
-        "import": "./dist/protocol.mjs",
-        "require": "./dist/protocol.cjs"
-      }
-    }
+    "access": "public"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
@@ -101,12 +82,14 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@likec4/core": "1.18.0",
-    "@likec4/log": "1.18.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",
     "fast-equals": "^5.0.1",
+    "fdir": "^6.4.2",
     "indent-string": "^5.0.0",
     "json5": "^2.2.3",
     "langium": "3.3.0",
@@ -118,20 +101,23 @@
     "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.18.0",
-    "@likec4/tsconfig": "1.18.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",
+    "natural-compare-lite": "^1.4.0",
     "npm-run-all2": "^7.0.1",
-    "tsx": "~4.9.3",
+    "tsx": "~4.19.2",
     "turbo": "^2.3.3",
     "typescript": "^5.7.2",
-    "unbuild": "^3.0.0-rc.11",
+    "unbuild": "^3.1.0",
     "vitest": "^2.1.8"
   },
   "packageManager": "yarn@4.5.3"

package/src/LikeC4FileSystem.ts

@@ -1,11 +1,11 @@
-import { type FileSystemNode, URI, UriUtils } from 'langium'
+import { fdir } from 'fdir'
+import { type FileSystemNode, URI } from 'langium'
 import { NodeFileSystemProvider } from 'langium/node'
-import { lstatSync, readlinkSync } from 'node:fs'
-import { readdir } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
+import { stat } from 'node:fs/promises'
+import { logger } from './logger'
 
 export const LikeC4FileSystem = {
-  fileSystemProvider: () => new SymLinkTraversingFileSystemProvider()
+  fileSystemProvider: () => new SymLinkTraversingFileSystemProvider(),
 }
 
 /**
@@ -14,23 +14,24 @@ export const LikeC4FileSystem = {
  */
 class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
   override async readDirectory(folderPath: URI): Promise<FileSystemNode[]> {
-    const dirents = await readdir(folderPath.fsPath, { withFileTypes: true })
-    return dirents.map(dirent => (this.followUri(UriUtils.joinPath(folderPath, dirent.name))))
-  }
-
-  followUri(uri: URI): FileSystemNode {
-    const directoryPath = dirname(uri.fsPath)
-    const stat = lstatSync(uri.fsPath)
-    if (stat.isSymbolicLink()) {
-      const resolved_link = readlinkSync(uri.fsPath)
-      const linked_path = resolve(directoryPath, resolved_link)
-      return this.followUri(URI.file(linked_path))
-    } else {
-      return {
-        isFile: stat.isFile(),
-        isDirectory: stat.isDirectory(),
-        uri
+    const crawled = await new fdir()
+      .withSymlinks()
+      .withFullPaths()
+      .crawl(folderPath.fsPath)
+      .withPromise()
+    const entries = [] as FileSystemNode[]
+    for (const path of crawled) {
+      try {
+        const stats = await stat(path)
+        entries.push({
+          isFile: stats.isFile(),
+          isDirectory: stats.isDirectory(),
+          uri: URI.file(path),
+        })
+      } catch (error) {
+        logger.error(error)
       }
     }
+    return entries
   }
 }