@likec4/language-server 1.25.0 → 1.26.0

package/dist/workspace/ProjectsManager.js

@@ -0,0 +1,150 @@
+import { BiMap, invariant, nonNullable } from "@likec4/core";
+import { URI, WorkspaceCache } from "langium";
+import { hasAtLeast, map, pipe, prop, sortBy } from "remeda";
+import { hasProtocol, joinRelativeURL, parseFilename, withoutProtocol, withProtocol } from "ufo";
+import { parseConfigJson } from "../config/index.js";
+import { logger as mainLogger } from "../logger.js";
+const logger = mainLogger.getChild("ProjectsManager");
+export class ProjectsManager {
+  constructor(services) {
+    this.services = services;
+    logger.debug`created`;
+  }
+  /**
+   * The global project ID used for all documents
+   * that are not part of a specific project.
+   */
+  static DefaultProjectId = "default";
+  static ConfigFileNames = [
+    ".likec4rc",
+    ".likec4.config.json",
+    "likec4.config.json"
+  ];
+  /**
+   * The mapping between project config files and project IDs.
+   */
+  projectIdToFolder = new BiMap();
+  // The mapping between document URIs and their corresponding project IDs.
+  _mappingsToProject;
+  /**
+   * Registered projects.
+   * Sorted descending by the number of segments in the folder path.
+   * This ensures that the most specific project is used for a document.
+   */
+  _projects = [];
+  get defaultProjectId() {
+    if (this._projects.length > 1) {
+      return void 0;
+    }
+    return this._projects[0]?.id ?? ProjectsManager.DefaultProjectId;
+  }
+  get all() {
+    if (hasAtLeast(this._projects, 1)) {
+      return [
+        ...map(this._projects, prop("id")),
+        ProjectsManager.DefaultProjectId
+      ];
+    }
+    return [ProjectsManager.DefaultProjectId];
+  }
+  getProject(projectId) {
+    if (projectId === ProjectsManager.DefaultProjectId) {
+      const folder = this.services.workspace.WorkspaceManager.workspaceUri;
+      return {
+        folder,
+        config: {
+          name: ProjectsManager.DefaultProjectId
+        }
+      };
+    }
+    const project = nonNullable(this._projects.find(({ id }) => id === projectId), `Project "${projectId}" not found`);
+    return {
+      folder: URI.parse(project.folder),
+      config: project.config
+    };
+  }
+  ensureProjectId(projectId) {
+    if (projectId === ProjectsManager.DefaultProjectId) {
+      return projectId;
+    }
+    if (projectId) {
+      invariant(this.projectIdToFolder.has(projectId), `Project ID ${projectId} is not registered`);
+      return projectId;
+    }
+    return nonNullable(
+      this.defaultProjectId,
+      () => `Specify exact project, known: [${[...this.projectIdToFolder.keys()].join(", ")}]`
+    );
+  }
+  hasMultipleProjects() {
+    return this._projects.length > 1;
+  }
+  /**
+   * Checks if the provided file system entry is a valid project config file.
+   *
+   * @param entry The file system entry to check
+   * @returns {boolean} Returns true if the entry is a valid config file, false otherwise.
+   */
+  async loadConfigFile(entry) {
+    if (entry.isDirectory) {
+      return false;
+    }
+    const filename = parseFilename(entry.uri.fsPath, { strict: false });
+    if (!filename) {
+      return false;
+    }
+    if (ProjectsManager.ConfigFileNames.includes(filename)) {
+      await this.registerProject(entry.uri);
+      return true;
+    }
+    return false;
+  }
+  async registerProject(opts) {
+    if (URI.isUri(opts)) {
+      const configFile = opts;
+      const cfg = await this.services.workspace.FileSystemProvider.readFile(configFile);
+      const config2 = parseConfigJson(cfg);
+      const path = joinRelativeURL(configFile.path, "..");
+      const folderUri2 = configFile.with({ path });
+      return this.registerProject({ config: config2, folderUri: folderUri2 });
+    }
+    const { config, folderUri } = opts;
+    const id = config.name;
+    if (this._projects.some(({ id: existingId }) => existingId === id)) {
+      throw new Error(`Project ID ${id} already registered`);
+    }
+    let folder;
+    if (URI.isUri(folderUri)) {
+      folder = folderUri.toString();
+    } else {
+      folder = hasProtocol(folderUri) ? folderUri : withProtocol(folderUri, "file://");
+    }
+    this._projects = pipe(
+      [...this._projects, { folder, config, id }],
+      sortBy(
+        [({ folder: folder2 }) => withoutProtocol(folder2).split("/").length, "desc"]
+      )
+    );
+    this.projectIdToFolder.set(id, folder);
+    logger.debug`registered project ${id} folder: ${folder})`;
+  }
+  belongsTo(document) {
+    let documentUri;
+    if (typeof document === "string") {
+      documentUri = hasProtocol(document) ? document : withProtocol(document, "file://");
+    } else if (URI.isUri(document)) {
+      documentUri = document.toString();
+    } else {
+      documentUri = document.uri.toString();
+    }
+    return this.mappingsToProject.get(documentUri, () => this.getProjectId(documentUri));
+  }
+  getProjectId(documentUri) {
+    const project = this._projects.find(({ folder }) => documentUri.toString().startsWith(folder));
+    return project?.id ?? ProjectsManager.DefaultProjectId;
+  }
+  get mappingsToProject() {
+    this._mappingsToProject ??= new WorkspaceCache(this.services);
+    return this._mappingsToProject;
+  }
+}

package/dist/{shared → workspace}/WorkspaceManager.d.ts

@@ -1,17 +1,23 @@
 import type { LangiumDocument } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
-import type { LangiumSharedServices } from 'langium/lsp';
 import type { WorkspaceFolder } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
+import type { LikeC4SharedServices } from '../module';
 export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
     private documentFactory;
-    constructor(services: LangiumSharedServices);
+    private projects;
+    constructor(services: LikeC4SharedServices);
     /**
      * Load all additional documents that shall be visible in the context of the given workspace
      * folders and add them to the collector. This can be used to include built-in libraries of
      * your language, which can be either loaded from provided files or constructed in memory.
      */
     protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
+    /**
+     * We override the default implementation to process project config files during the traversal.
+     * This is necessary to ensure that the project config files are loaded and processed correctly.
+     */
+    protected traverseFolder(workspaceFolder: WorkspaceFolder, folderPath: URI, fileExtensions: string[], collector: (document: LangiumDocument) => void): Promise<void>;
     workspace(): any;
     get workspaceUri(): URI;
     get workspaceURL(): URL;

package/dist/{shared → workspace}/WorkspaceManager.js

@@ -4,9 +4,11 @@ import { URI } from "vscode-uri";
 import * as BuiltIn from "../likec4lib.js";
 export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
   documentFactory;
+  projects;
   constructor(services) {
     super(services);
     this.documentFactory = services.workspace.LangiumDocumentFactory;
+    this.projects = services.workspace.ProjectsManager;
   }
   /**
    * Load all additional documents that shall be visible in the context of the given workspace
@@ -17,6 +19,26 @@ export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
     collector(this.documentFactory.fromString(BuiltIn.Content, URI.parse(BuiltIn.Uri)));
     await super.loadAdditionalDocuments(folders, collector);
   }
+  /**
+   * We override the default implementation to process project config files during the traversal.
+   * This is necessary to ensure that the project config files are loaded and processed correctly.
+   */
+  async traverseFolder(workspaceFolder, folderPath, fileExtensions, collector) {
+    const content = await this.fileSystemProvider.readDirectory(folderPath);
+    await Promise.all(content.map(async (entry) => {
+      if (await this.projects.loadConfigFile(entry)) {
+        return;
+      }
+      if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {
+        if (entry.isDirectory) {
+          await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector);
+        } else if (entry.isFile) {
+          const document = await this.langiumDocuments.getOrCreateDocument(entry.uri);
+          collector(document);
+        }
+      }
+    }));
+  }
   workspace() {
     if (this.folders && hasAtLeast(this.folders, 1)) {
       return this.folders[0];

package/dist/workspace/index.d.ts

@@ -0,0 +1,5 @@
+export * from './AstNodeDescriptionProvider';
+export * from './IndexManager';
+export * from './LangiumDocuments';
+export * from './ProjectsManager';
+export * from './WorkspaceManager';

package/dist/workspace/index.js

@@ -0,0 +1,5 @@
+export * from "./AstNodeDescriptionProvider.js";
+export * from "./IndexManager.js";
+export * from "./LangiumDocuments.js";
+export * from "./ProjectsManager.js";
+export * from "./WorkspaceManager.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -42,6 +42,14 @@
         "default": "./dist/browser.js"
       }
     },
+    "./config": {
+      "sources": "./src/config/index.ts",
+      "default": {
+        "types": "./dist/config/index.d.ts",
+        "import": "./dist/config/index.js",
+        "default": "./dist/config/index.js"
+      }
+    },
     "./likec4lib": {
       "sources": "./src/likec4lib.ts",
       "default": {
@@ -84,9 +92,9 @@
     "@hpcc-js/wasm-graphviz": "1.7.0",
     "@msgpack/msgpack": "^3.1.0",
     "@smithy/util-base64": "^4.0.0",
-    "@types/node": "^20.17.17",
+    "@types/node": "^20.17.23",
     "@types/which": "^3.0.4",
-    "@vitest/coverage-v8": "^3.0.6",
+    "@vitest/coverage-v8": "^3.0.8",
     "esm-env": "^1.2.2",
     "fast-equals": "^5.2.2",
     "fdir": "^6.4.3",
@@ -97,25 +105,26 @@
     "natural-compare-lite": "^1.4.0",
     "p-debounce": "^4.0.0",
     "pretty-ms": "^9.2.0",
-    "remeda": "^2.20.2",
+    "remeda": "^2.21.0",
     "strip-indent": "^4.0.0",
     "tsx": "~4.19.3",
-    "turbo": "^2.4.2",
+    "turbo": "^2.4.4",
     "type-fest": "4.34.1",
-    "typescript": "5.7.3",
+    "typescript": "5.8.2",
     "ufo": "^1.5.4",
     "unbuild": "^3.3.1",
-    "vitest": "^3.0.6",
+    "valibot": "^1.0.0-rc.3",
+    "vitest": "^3.0.8",
     "vscode-jsonrpc": "8.2.0",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-types": "3.17.5",
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
-    "@likec4/core": "1.25.0",
-    "@likec4/layouts": "1.25.0",
-    "@likec4/log": "1.25.0",
-    "@likec4/tsconfig": "1.25.0",
-    "@likec4/icons": "1.25.0"
+    "@likec4/core": "1.26.0",
+    "@likec4/icons": "1.26.0",
+    "@likec4/layouts": "1.26.0",
+    "@likec4/log": "1.26.0",
+    "@likec4/tsconfig": "1.26.0"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",