@likec4/language-server 0.37.1 → 0.41.0

package/dist/view-utils/resolve-extended-views.js

@@ -0,0 +1,41 @@
+import graphlib from "@dagrejs/graphlib";
+import { isExtendsElementView } from "@likec4/core";
+const { Graph, alg } = graphlib;
+export function resolveRulesExtendedViews(unresolvedViews) {
+  const g = new Graph({
+    directed: true,
+    multigraph: false,
+    compound: false
+  });
+  for (const view of Object.values(unresolvedViews)) {
+    g.setNode(view.id);
+    if (isExtendsElementView(view)) {
+      g.setEdge(view.id, view.extends);
+    }
+  }
+  const cycles = alg.findCycles(g);
+  if (cycles.length > 0) {
+    cycles.flat().forEach((id) => g.removeNode(id));
+  }
+  const ordered = alg.postorder(g, g.sources());
+  return ordered.reduce((acc, id) => {
+    const view = unresolvedViews[id];
+    if (!view) {
+      return acc;
+    }
+    if (isExtendsElementView(view)) {
+      const extendsFrom = acc[view.extends];
+      if (!extendsFrom) {
+        return acc;
+      }
+      return Object.assign(acc, {
+        [view.id]: {
+          ...extendsFrom,
+          ...view,
+          rules: [...extendsFrom.rules, ...view.rules]
+        }
+      });
+    }
+    return Object.assign(acc, { [view.id]: view });
+  }, {});
+}

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

@@ -0,0 +1,3 @@
+import type { ElementView } from '@likec4/core';
+export declare function resolveRelativePaths(views: ElementView[]): ElementView[];
+//# sourceMappingURL=resolve-relative-paths.d.ts.map

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

@@ -0,0 +1,76 @@
+import { uniq, zip } from "rambdax";
+import { hasAtLeast } from "remeda";
+import { invariant } from "@likec4/core";
+function commonAncestorPath(views, sep = "/") {
+  if (views.length <= 1)
+    return "";
+  const uniqURIs = uniq(views.flatMap(({ docUri }) => docUri ? [docUri] : []));
+  if (uniqURIs.length === 0)
+    return "";
+  if (uniqURIs.length === 1) {
+    invariant(hasAtLeast(uniqURIs, 1));
+    return new URL(uniqURIs[0]).pathname;
+  }
+  invariant(hasAtLeast(uniqURIs, 2), "Expected at least 2 unique URIs");
+  const [baseUri, ...tail] = uniqURIs;
+  const parts = new URL(baseUri).pathname.split(sep);
+  let endOfPrefix = parts.length;
+  for (const uri of tail) {
+    if (uri === baseUri) {
+      continue;
+    }
+    const compare = new URL(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 commonPrefix = commonAncestorPath(views);
+  return views.map((view) => {
+    if (!view.docUri) {
+      return {
+        ...view,
+        parts: []
+      };
+    }
+    const path = new URL(view.docUri).pathname;
+    const parts = path.replace(commonPrefix, "").split("/");
+    parts.pop();
+    return {
+      ...view,
+      parts
+    };
+  }).sort((a, b) => {
+    if (a.parts.length === b.parts.length) {
+      if (a.parts.length === 0) {
+        return 0;
+      }
+      if (a.parts.length === 1 && hasAtLeast(a.parts, 1) && hasAtLeast(b.parts, 1)) {
+        return a.parts[0].localeCompare(b.parts[0]);
+      }
+      for (const [_a, _b] of zip(a.parts, b.parts)) {
+        const compare = _a.localeCompare(_b);
+        if (compare !== 0) {
+          return compare;
+        }
+      }
+      return 0;
+    }
+    return a.parts.length - b.parts.length;
+  }).map(({ parts, ...view }) => {
+    if (view.docUri) {
+      return {
+        ...view,
+        relativePath: parts.join("/")
+      };
+    }
+    return view;
+  });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.37.1",
+  "version": "0.41.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -20,46 +20,61 @@
     "directory": "packages/language-server"
   },
   "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public"
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
   },
   "scripts": {
-    "turbo-build": "run -T turbo run build --filter='language-server'",
-    "turbo-compile": "run -T turbo run compile --filter='language-server'",
-    "compile": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
     "watch:langium": "langium generate --watch",
     "watch:ts": "tsc --watch",
     "generate": "langium generate",
-    "build": "tsc",
+    "prepack": "unbuild",
+    "build:turbo": "run -T turbo build --filter='language-server'",
+    "build": "unbuild",
     "dev": "run-p 'watch:*'",
     "lint": "run -T eslint src/ --fix",
     "clean": "run -T rimraf dist contrib",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "0.37.1",
+    "@likec4/core": "0.41.0",
+    "@likec4/graph": "0.41.0",
     "langium": "^2.0.2",
-    "nanoid": "^4.0.2",
     "object-hash": "^3.0.0",
+    "p-debounce": "^4.0.0",
+    "p-throttle": "^5.1.0",
     "rambdax": "^9.1.1",
-    "remeda": "^1.24.0",
+    "remeda": "^1.27.1",
     "strip-indent": "^4.0.0",
     "vscode-languageserver": "~8.1.0",
     "vscode-languageserver-protocol": "~3.17.3",
     "vscode-uri": "~3.0.7"
   },
   "devDependencies": {
-    "@types/node": "^18.15.11",
-    "@types/object-hash": "^3.0.2",
+    "@types/node": "^20.8.7",
+    "@types/object-hash": "^3.0.5",
+    "execa": "^8.0.1",
     "langium-cli": "^2.0.1",
     "npm-run-all": "^4.1.5",
     "typescript": "^5.2.2",
-    "vitest": "^0.34.4"
+    "unbuild": "^2.0.0",
+    "vitest": "^0.34.6"
   },
-  "packageManager": "yarn@3.6.3"
+  "packageManager": "yarn@3.6.4",
+  "volta": {
+    "extends": "../../package.json"
+  }
 }

package/dist/registerProtocolHandlers.d.ts

@@ -1,3 +0,0 @@
-import type { LikeC4Services } from './module';
-export declare function registerProtocolHandlers(services: LikeC4Services): void;
-//# sourceMappingURL=registerProtocolHandlers.d.ts.map

package/dist/registerProtocolHandlers.js

@@ -1,112 +0,0 @@
-import { URI } from 'vscode-uri';
-import { logger, logError } from './logger';
-import { Rpc } from './protocol';
-import { nonexhaustive } from '@likec4/core';
-import { isLikeC4LangiumDocument } from './ast';
-export function registerProtocolHandlers(services) {
-    const connection = services.shared.lsp.Connection;
-    if (!connection) {
-        return;
-    }
-    const modelBuilder = services.likec4.ModelBuilder;
-    const modelLocator = services.likec4.ModelLocator;
-    const LangiumDocuments = services.shared.workspace.LangiumDocuments;
-    connection.onRequest(Rpc.fetchModel, async (_cancelToken) => {
-        let model;
-        try {
-            model = modelBuilder.buildModel() ?? null;
-        }
-        catch (e) {
-            model = null;
-            logError(e);
-        }
-        return Promise.resolve({ model });
-    });
-    connection.onRequest(Rpc.fetchRawModel, async (_cancelToken) => {
-        let rawmodel;
-        try {
-            rawmodel = modelBuilder.buildRawModel() ?? null;
-        }
-        catch (e) {
-            rawmodel = null;
-            logError(e);
-        }
-        return Promise.resolve({ rawmodel });
-    });
-    connection.onRequest(Rpc.computeView, ({ viewId }) => {
-        return {
-            view: modelBuilder.computeView(viewId)
-        };
-    });
-    connection.onRequest(Rpc.rebuild, async (cancelToken) => {
-        const changed = LangiumDocuments.all
-            .map(d => {
-            // clean up any computed properties
-            if (isLikeC4LangiumDocument(d)) {
-                delete d.c4Specification;
-                delete d.c4Elements;
-                delete d.c4Relations;
-                delete d.c4Views;
-                delete d.c4fqns;
-            }
-            return d.uri;
-        })
-            .toArray();
-        logger.debug(`[ProtocolHandlers] rebuild all documents: [
-      ${changed.map(d => d.toString()).join('\n      ')}
-    ]`);
-        await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
-        return {
-            docs: changed.map(d => d.toString())
-        };
-    });
-    connection.onRequest(Rpc.buildDocuments, async ({ docs }, cancelToken) => {
-        if (docs.length === 0) {
-            logger.debug(`[ProtocolHandlers] received empty request to rebuild`);
-            return;
-        }
-        logger.debug(`[ProtocolHandlers] received request to buildDocuments:
-  - ${docs.join('\n  - ')}`);
-        const changed = [];
-        for (const d of docs) {
-            try {
-                const uri = URI.parse(d);
-                if (LangiumDocuments.hasDocument(uri)) {
-                    changed.push(uri);
-                }
-                else {
-                    logger.warn(`LangiumDocuments does not have document: ${d}`);
-                    LangiumDocuments.getOrCreateDocument(uri);
-                }
-            }
-            catch (e) {
-                logError(e);
-            }
-        }
-        if (changed.length !== docs.length) {
-            const all = LangiumDocuments.all.map(d => d.uri.toString()).toArray();
-            logger.warn(`
-We have in LangiumDocuments: [
-  ${all.join('\n  ')}
-]
-We rebuild: [
-  ${changed.join('\n  ')}
-]
-`.trim());
-        }
-        await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
-    });
-    connection.onRequest(Rpc.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);
-        }
-        nonexhaustive(params);
-    });
-}
-//# sourceMappingURL=registerProtocolHandlers.js.map