@likec4/language-server 1.36.0 → 1.37.0

package/dist/workspace/ProjectsManager.d.ts

@@ -1,14 +1,27 @@
 import type { NonEmptyReadonlyArray, ProjectId } from '@likec4/core';
-import { type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
-import picomatch from 'picomatch/posix';
+import { type Cancellation, type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import picomatch from 'picomatch';
+import type { Tagged } from 'type-fest';
 import { ProjectConfig } from '../config';
 import type { LikeC4SharedServices } from '../module';
-interface Project {
+/**
+ * A tagged string that represents a project folder.
+ * Always has trailing slash.
+ */
+export type ProjectFolder = Tagged<string, 'ProjectFolder'>;
+export declare function ProjectFolder(folder: URI | string): ProjectFolder;
+interface ProjectData {
     id: ProjectId;
     config: ProjectConfig;
-    folder: string;
+    folder: ProjectFolder;
+    folderUri: URI;
     exclude?: picomatch.Matcher;
 }
+export interface Project {
+    id: ProjectId;
+    folderUri: URI;
+    config: ProjectConfig;
+}
 export declare class ProjectsManager {
     protected services: LikeC4SharedServices;
     /**
@@ -27,7 +40,9 @@ export declare class ProjectsManager {
      * This ensures that the most specific project is used for a document.
      */
     private _projects;
+    private excludedDocuments;
     private defaultGlobalProject;
+    private reloadProjectsLimiter;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns:
@@ -37,29 +52,32 @@ export declare class ProjectsManager {
      */
     get defaultProjectId(): ProjectId | undefined;
     get all(): NonEmptyReadonlyArray<ProjectId>;
-    getProject(arg: ProjectId | LangiumDocument): {
-        id: ProjectId;
-        folder: URI;
-        config: Readonly<ProjectConfig>;
-    };
+    getProject(arg: ProjectId | LangiumDocument): Project;
     ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
     hasMultipleProjects(): boolean;
-    checkIfExcluded(documentUri: URI): boolean;
-    isConfigFile(entry: FileSystemNode): boolean;
+    checkIfExcluded(document: LangiumDocument | URI | string): boolean;
+    /**
+     * Checks if it is a config file and it is not excluded by default exclude pattern
+     *
+     * @param entry The file system entry to check
+     */
+    isConfigFile(entry: URI): boolean;
     /**
      * Checks if the provided file system entry is a valid project config file.
      *
      * @param entry The file system entry to check
      */
-    loadConfigFile(entry: FileSystemNode): Promise<Project | undefined>;
-    registerProject(configFile: URI): Promise<Project>;
+    loadConfigFile(entry: FileSystemNode): Promise<ProjectData | undefined>;
+    registerProject(configFile: URI): Promise<ProjectData>;
     registerProject(opts: {
         config: ProjectConfig;
         folderUri: URI | string;
-    }): Promise<Project>;
+    }): Promise<ProjectData>;
     belongsTo(document: LangiumDocument | URI | string): ProjectId;
-    protected findProjectForDocument(documentUri: string): Omit<Project, 'folder'>;
-    private _mappingsToProject;
-    protected get mappingsToProject(): WorkspaceCache<string, Omit<Project, 'folder'>>;
+    reloadProjects(token?: Cancellation.CancellationToken): Promise<void>;
+    protected uniqueProjectId(name: string): ProjectId;
+    protected resetProjectIds(): void;
+    protected findProjectForDocument(documentUri: string): any;
+    protected get mappingsToProject(): WorkspaceCache<string, Pick<ProjectData, 'id' | 'config' | 'exclude'>>;
 }
 export {};

package/dist/workspace/ProjectsManager.js

@@ -1,18 +1,33 @@
-import { BiMap, invariant, nonNullable } from "@likec4/core";
+import { BiMap, delay, invariant, memoizeProp, nonNullable } from "@likec4/core";
 import { loggable } from "@likec4/log";
-import { URI, WorkspaceCache } from "langium";
-import picomatch from "picomatch/posix";
-import { hasAtLeast, isNullish, map, pipe, prop, sortBy } from "remeda";
+import { deepEqual } from "fast-equals";
+import {
+  interruptAndCheck,
+  URI,
+  WorkspaceCache
+} from "langium";
+import PQueue from "p-queue";
+import picomatch from "picomatch";
+import { hasAtLeast, isNullish, isTruthy, map, pickBy, pipe, prop, sortBy } from "remeda";
 import {
   hasProtocol,
   joinRelativeURL,
+  normalizeURL,
   parseFilename,
   withoutProtocol,
-  withProtocol
+  withProtocol,
+  withTrailingSlash
 } from "ufo";
 import { parseConfigJson, validateConfig } from "../config/index.js";
 import { logger as mainLogger } from "../logger.js";
 const logger = mainLogger.getChild("ProjectsManager");
+export function ProjectFolder(folder) {
+  if (URI.isUri(folder)) {
+    folder = folder.toString();
+  }
+  folder = hasProtocol(folder) ? folder : withProtocol(folder, "file://");
+  return withTrailingSlash(normalizeURL(folder));
+}
 export class ProjectsManager {
   constructor(services) {
     this.services = services;
@@ -38,14 +53,19 @@ export class ProjectsManager {
    * This ensures that the most specific project is used for a document.
    */
   _projects = [];
+  excludedDocuments = /* @__PURE__ */ new WeakMap();
   defaultGlobalProject = {
     id: ProjectsManager.DefaultProjectId,
     config: {
       name: ProjectsManager.DefaultProjectId,
-      exclude: ["**/node_modules/**/*"]
+      exclude: ["**/node_modules/**"]
     },
-    exclude: picomatch("**/node_modules/**/*")
+    exclude: picomatch("**/node_modules/**", { dot: true })
   };
+  reloadProjectsLimiter = new PQueue({
+    concurrency: 1,
+    timeout: 2e4
+  });
   /**
    * Returns:
    *  - the default project ID if there are no projects.
@@ -70,20 +90,26 @@ export class ProjectsManager {
   getProject(arg) {
     const id = typeof arg === "string" ? arg : arg.likec4ProjectId || this.belongsTo(arg);
     if (id === ProjectsManager.DefaultProjectId) {
-      const folder2 = this.services.workspace.WorkspaceManager.workspaceUri;
+      let folderUri2;
+      try {
+        folderUri2 = this.services.workspace.WorkspaceManager.workspaceUri;
+      } catch (error) {
+        logger.warn("Failed to get workspace URI, using default folder", { error });
+        folderUri2 = URI.file("");
+      }
       return {
-        id,
-        folder: folder2,
-        config: this.defaultGlobalProject.config
+        id: ProjectsManager.DefaultProjectId,
+        config: this.defaultGlobalProject.config,
+        folderUri: folderUri2
       };
     }
     const {
       config,
-      folder
+      folderUri
     } = nonNullable(this._projects.find((p) => p.id === id), `Project "${id}" not found`);
     return {
       id,
-      folder: URI.parse(folder),
+      folderUri,
       config
     };
   }
@@ -103,14 +129,34 @@ export class ProjectsManager {
   hasMultipleProjects() {
     return this._projects.length > 1;
   }
-  checkIfExcluded(documentUri) {
-    let docUriAsString = documentUri.toString();
-    const project = this.findProjectForDocument(docUriAsString);
-    return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+  checkIfExcluded(document) {
+    if (typeof document === "string" || URI.isUri(document)) {
+      let docUriAsString = typeof document === "string" ? document : document.toString();
+      const project = this.findProjectForDocument(docUriAsString);
+      return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+    }
+    let isExcluded = this.excludedDocuments.get(document);
+    if (isExcluded === void 0) {
+      isExcluded = this.checkIfExcluded(document.uri);
+      this.excludedDocuments.set(document, isExcluded);
+    }
+    return isExcluded;
   }
+  /**
+   * Checks if it is a config file and it is not excluded by default exclude pattern
+   *
+   * @param entry The file system entry to check
+   */
   isConfigFile(entry) {
-    const filename = parseFilename(entry.uri.toString(), { strict: false })?.toLowerCase();
-    return !!filename && ProjectsManager.ConfigFileNames.includes(filename);
+    const filename = parseFilename(entry.toString(), { strict: false })?.toLowerCase();
+    const isConfigFile = !!filename && ProjectsManager.ConfigFileNames.includes(filename);
+    if (isConfigFile) {
+      if (this.defaultGlobalProject.exclude(entry.path)) {
+        logger.debug`exclude config file ${entry.path}`;
+        return false;
+      }
+    }
+    return isConfigFile;
   }
   /**
    * Checks if the provided file system entry is a valid project config file.
@@ -121,7 +167,7 @@ export class ProjectsManager {
     if (entry.isDirectory) {
       return void 0;
     }
-    if (this.isConfigFile(entry)) {
+    if (this.isConfigFile(entry.uri)) {
       try {
         return await this.registerProject(entry.uri);
       } catch (error) {
@@ -143,39 +189,55 @@ ${loggable(error)}`
       const config2 = parseConfigJson(cfg);
       const path = joinRelativeURL(configFile.path, "..");
       const folderUri2 = configFile.with({ path });
-      return this.registerProject({ config: config2, folderUri: folderUri2 });
+      return await this.registerProject({ config: config2, folderUri: folderUri2 });
     }
-    const config = validateConfig(opts.config);
+    const config = pickBy(validateConfig(opts.config), isTruthy);
     const { folderUri } = opts;
-    let id = config.name;
-    let i = 1;
-    while (this.projectIdToFolder.has(id)) {
-      id = `${config.name}-${i++}`;
+    const folder = ProjectFolder(folderUri);
+    let project = this._projects.find((p) => p.folder === folder);
+    if (project && deepEqual(project.config, config)) {
+      return project;
     }
-    let folder;
-    if (URI.isUri(folderUri)) {
-      folder = folderUri.toString();
+    let mustReset = !!project && !deepEqual(project.config, config);
+    let id;
+    if (!project) {
+      id = this.uniqueProjectId(config.name);
+      project = {
+        id,
+        config,
+        folder,
+        folderUri: URI.parse(folder)
+      };
+      mustReset = this._projects.some((p) => p.folder.startsWith(folder) || folder.startsWith(p.folder));
+      this._projects = pipe(
+        [...this._projects, project],
+        sortBy(
+          [({ folder: folder2 }) => withoutProtocol(folder2).split("/").length, "desc"]
+        )
+      );
+      logger.info`register project ${project.id} folder: ${folder}`;
     } else {
-      folder = hasProtocol(folderUri) ? folderUri : withProtocol(folderUri, "file://");
+      if (project.config.name !== config.name) {
+        this.projectIdToFolder.delete(project.id);
+        logger.info`unregister project ${project.id} folder: ${folder}`;
+        id = this.uniqueProjectId(config.name);
+        project.id = id;
+        logger.info`re-register project ${project.id} folder: ${folder}`;
+      } else {
+        id = project.id;
+        logger.info`update project ${project.id} on config change`;
+      }
+      project.config = config;
     }
-    const project = {
-      id,
-      config,
-      folder
-    };
     if (isNullish(config.exclude)) {
       project.exclude = this.defaultGlobalProject.exclude;
     } else if (hasAtLeast(config.exclude, 1)) {
-      project.exclude = picomatch(config.exclude);
+      project.exclude = picomatch(config.exclude, { dot: true });
+    }
+    this.projectIdToFolder.set(project.id, folder);
+    if (mustReset) {
+      this.resetProjectIds();
     }
-    this._projects = pipe(
-      [...this._projects, project],
-      sortBy(
-        [({ folder: folder2 }) => withoutProtocol(folder2).split("/").length, "desc"]
-      )
-    );
-    this.projectIdToFolder.set(id, folder);
-    logger.info`register project ${id} folder: ${folder}`;
     return project;
   }
   belongsTo(document) {
@@ -189,6 +251,68 @@ ${loggable(error)}`
     }
     return this.findProjectForDocument(documentUri).id;
   }
+  async reloadProjects(token) {
+    const folders = this.services.workspace.WorkspaceManager.workspaceFolders;
+    if (!folders) {
+      logger.warn("No workspace folders found");
+      return;
+    }
+    if (this.reloadProjectsLimiter.size + this.reloadProjectsLimiter.pending > 0) {
+      logger.debug`reload projects is already queued`;
+      return;
+    }
+    this.reloadProjectsLimiter.add(async () => {
+      await delay(100);
+    });
+    this.reloadProjectsLimiter.add(async () => {
+      if (token) {
+        await interruptAndCheck(token);
+      }
+      logger.debug`reload projects`;
+      const configFiles = [];
+      for (const folder of folders) {
+        try {
+          const files = await this.services.workspace.FileSystemProvider.readDirectory(URI.parse(folder.uri));
+          for (const file of files) {
+            if (file.isFile && this.isConfigFile(file.uri)) {
+              configFiles.push(file);
+            }
+          }
+        } catch (error) {
+          logger.error("Failed to load config file", { error });
+        }
+      }
+      if (configFiles.length === 0 && this._projects.length !== 0) {
+        logger.warning("No config files found, but some projects were registered before");
+      }
+      this._projects = [];
+      this.projectIdToFolder.clear();
+      for (const entry of configFiles) {
+        try {
+          await this.registerProject(entry.uri);
+        } catch (error) {
+          logger.error("Failed to load config file", { error });
+        }
+      }
+      this.resetProjectIds();
+      const docs = this.services.workspace.LangiumDocuments.all.map((d) => d.uri).toArray();
+      logger.info("invalidate and rebuild documents {docs}", { docs: docs.length });
+      await this.services.workspace.DocumentBuilder.update(docs, []);
+    });
+  }
+  uniqueProjectId(name) {
+    let id = name;
+    let i = 1;
+    while (this.projectIdToFolder.has(id)) {
+      id = `${name}-${i++}`;
+    }
+    return id;
+  }
+  resetProjectIds() {
+    this.mappingsToProject.clear();
+    this.excludedDocuments = /* @__PURE__ */ new WeakMap();
+    this.services.workspace.LangiumDocuments.resetProjectIds();
+  }
   findProjectForDocument(documentUri) {
     return this.mappingsToProject.get(documentUri, () => {
       const project = this._projects.find(({ folder }) => documentUri.startsWith(folder));
@@ -197,9 +321,7 @@ ${loggable(error)}`
   }
   // The mapping between document URIs and their corresponding project ID
   // Lazy-created due to initialization order of the LanguageServer
-  _mappingsToProject;
   get mappingsToProject() {
-    this._mappingsToProject ??= new WorkspaceCache(this.services);
-    return this._mappingsToProject;
+    return memoizeProp(this, "_mappingsToProject", () => new WorkspaceCache(this.services));
   }
 }

package/dist/workspace/WorkspaceManager.js

@@ -64,7 +64,7 @@ export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
    * Determine whether the given folder entry shall be included while indexing the workspace.
    */
   includeEntry(_workspaceFolder, entry, selector) {
-    if (this.services.workspace.ProjectsManager.isConfigFile(entry)) {
+    if (this.services.workspace.ProjectsManager.isConfigFile(entry.uri)) {
       return false;
     }
     if (entry.isFile) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.36.0",
+  "version": "1.37.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -133,11 +133,11 @@
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
     "zod": "3.25.67",
-    "@likec4/icons": "1.36.0",
-    "@likec4/tsconfig": "1.36.0",
-    "@likec4/layouts": "1.36.0",
-    "@likec4/log": "1.36.0",
-    "@likec4/core": "1.36.0"
+    "@likec4/core": "1.37.0",
+    "@likec4/icons": "1.37.0",
+    "@likec4/layouts": "1.37.0",
+    "@likec4/log": "1.37.0",
+    "@likec4/tsconfig": "1.37.0"
   },
   "scripts": {
     "typecheck": "tsc -b --verbose",