@likec4/language-server 1.18.0 → 1.19.0

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "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"
+      "development": "./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"
+      "development": "./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"
+      "development": "./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"
+      "development": "./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,13 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@likec4/core": "1.18.0",
-    "@likec4/log": "1.18.0",
+    "@likec4/core": "1.19.0",
+    "@likec4/log": "1.19.0",
     "@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",
@@ -121,17 +103,18 @@
     "vscode-uri": "3.0.8"
   },
   "devDependencies": {
-    "@likec4/icons": "1.18.0",
-    "@likec4/tsconfig": "1.18.0",
+    "@likec4/icons": "1.19.0",
+    "@likec4/tsconfig": "1.19.0",
     "@types/node": "^20.17.7",
     "@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
   }
 }