@likec4/language-server 1.46.2 → 1.46.4

package/dist/workspace/ProjectsManager.js

@@ -1,12 +1,12 @@
+var _a;
 import { isLikeC4Config, normalizeIncludeConfig, validateProjectConfig, } from '@likec4/config';
-import { BiMap, delay, invariant, memoizeProp, nonNullable } from '@likec4/core/utils';
+import { BiMap, DefaultMap, invariant, memoizeProp, nonNullable } from '@likec4/core/utils';
 import { wrapError } from '@likec4/log';
 import { deepEqual } from 'fast-equals';
 import { interruptAndCheck, URI, WorkspaceCache, } from 'langium';
 import picomatch from 'picomatch';
 import { hasAtLeast, isNullish, map, pipe, prop, sortBy } from 'remeda';
-import { joinRelativeURL, parseFilename, withoutProtocol, withTrailingSlash, } from 'ufo';
-import { isLikeC4Builtin } from '../likec4lib';
+import { cleanDoubleSlashes, isRelative, joinRelativeURL, joinURL, parseFilename, withoutProtocol, withTrailingSlash, } from 'ufo';
 import { logger as mainLogger } from '../logger';
 const logger = mainLogger.getChild('ProjectsManager');
 function normalizeUri(uri) {
@@ -21,6 +21,13 @@ function normalizeUri(uri) {
         return uri.uri.toString();
     }
 }
+/**
+ * Returns a predicate that checks if the given path is included in the project folder.
+ */
+function isParentFolderFor(uri) {
+    const path = normalizeUri(uri);
+    return (p) => path.startsWith(p.folder);
+}
 export function ProjectFolder(folder) {
     folder = normalizeUri(folder);
     return withTrailingSlash(folder);
@@ -60,6 +67,23 @@ export class ProjectsManager {
      * This ensures that the most specific project is used for a document.
      */
     #projects = [];
+    /**
+     * This is a cached lookup for performance.
+     */
+    #lookupById = new DefaultMap((id) => {
+        if (id === _a.DefaultProjectId) {
+            const folderUri = this.getWorkspaceFolder();
+            return {
+                id,
+                config: DefaultProject.config,
+                folder: ProjectFolder(folderUri),
+                folderUri,
+                exclude: DefaultProject.exclude,
+                includeConfig: DefaultProject.includeConfig,
+            };
+        }
+        return nonNullable(this.#projects.find(p => p.id === id), `Project ${id} not found`);
+    });
     #excludedDocuments = new WeakMap();
     constructor(services) {
         this.services = services;
@@ -79,14 +103,14 @@ export class ProjectsManager {
         if (this.#projects.length > 1) {
             return undefined;
         }
-        return this.#projects[0]?.id ?? ProjectsManager.DefaultProjectId;
+        return this.#projects[0]?.id ?? _a.DefaultProjectId;
     }
     set defaultProjectId(id) {
         if (id === this.#defaultProjectId) {
             return;
         }
         this.#defaultProject = undefined;
-        if (!id || id === ProjectsManager.DefaultProjectId) {
+        if (!id || id === _a.DefaultProjectId) {
             logger.debug `reset default project ID`;
             this.#defaultProjectId = undefined;
             return;
@@ -97,7 +121,7 @@ export class ProjectsManager {
     }
     get default() {
         if (!this.#defaultProject) {
-            const id = this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
+            const id = this.defaultProjectId ?? _a.DefaultProjectId;
             let project = this.#projects.find(p => p.id === id);
             if (!project) {
                 const folderUri = this.getWorkspaceFolder();
@@ -145,17 +169,17 @@ export class ProjectsManager {
                 // ignore - workspace not initialized
             }
             return {
-                id: ProjectsManager.DefaultProjectId,
+                id: _a.DefaultProjectId,
                 config: DefaultProject.config,
                 folderUri,
             };
         }
-        const project = nonNullable(this.#projects.find(p => p.id === id), `Project "${id}" not found`);
+        const project = nonNullable(this.#lookupById.get(id), `Project ${id} not found`);
         return {
             id,
             folderUri: project.folderUri,
             config: project.config,
-            ...(project.includePaths && { includePaths: project.includePaths.map(p => p.uri) }),
+            ...(project.includePaths && { includePaths: map(project.includePaths, prop('uri')) }),
         };
     }
     /**
@@ -164,8 +188,8 @@ export class ProjectsManager {
      * If there are multiple projects and default project is not set, throws an error
      */
     ensureProjectId(projectId) {
-        if (projectId === ProjectsManager.DefaultProjectId) {
-            return this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
+        if (projectId === _a.DefaultProjectId) {
+            return this.defaultProjectId ?? _a.DefaultProjectId;
         }
         if (projectId) {
             invariant(this.#projectIdToFolder.has(projectId), `Project ID ${projectId} is not registered`);
@@ -190,7 +214,11 @@ export class ProjectsManager {
         if (typeof document === 'string' || URI.isUri(document)) {
             let docUriAsString = normalizeUri(document);
             const project = this.findProjectForDocument(docUriAsString);
-            return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+            if (!project.exclude) {
+                return false;
+            }
+            const input = withoutProtocol(docUriAsString);
+            return project.exclude(input);
         }
         let isExcluded = this.#excludedDocuments.get(document);
         if (isExcluded === undefined) {
@@ -199,6 +227,25 @@ export class ProjectsManager {
         }
         return isExcluded;
     }
+    /**
+     * Checks if the specified document is included by the project:
+     * - if the document belongs to the project and is not excluded
+     * - if the document is included by the project
+     */
+    isIncluded(projectId, document) {
+        if (typeof document !== 'string' && !URI.isUri(document)) {
+            return this.isIncluded(projectId, document.uri);
+        }
+        const belongsTo = this.belongsTo(document);
+        if (belongsTo === projectId) {
+            return !this.isExcluded(document);
+        }
+        let includePaths = this.#lookupById.get(projectId)?.includePaths;
+        if (!includePaths) {
+            return false;
+        }
+        return includePaths.some(isParentFolderFor(document));
+    }
     /**
      * Checks if it is a config file and it is not excluded by default exclude pattern
      *
@@ -218,7 +265,7 @@ export class ProjectsManager {
     /**
      * Registers likec4 project by config file.
      */
-    async registerConfigFile(configFile) {
+    async registerConfigFile(configFile, cancelToken) {
         if (DefaultProject.exclude(configFile.path)) {
             throw new Error(`Path to ${configFile.fsPath} is excluded by: ${DefaultProject.config.exclude.join(', ')}`);
         }
@@ -229,7 +276,7 @@ export class ProjectsManager {
             const config = await this.services.workspace.FileSystemProvider.loadProjectConfig(configFile);
             const path = joinRelativeURL(configFile.path, '..');
             const folderUri = configFile.with({ path });
-            return await this.registerProject({ config, folderUri });
+            return await this.registerProject({ config, folderUri }, cancelToken);
         }
         catch (error) {
             this.services.lsp.Connection?.window.showErrorMessage(`LikeC4: Failed to register project at ${configFile.fsPath}`);
@@ -240,7 +287,7 @@ export class ProjectsManager {
      * Registers (or reloads) likec4 project by config file or config object.
      * If there is some project registered at same folder, it will be reloaded.
      */
-    async registerProject(opts) {
+    async registerProject(opts, cancelToken) {
         const config = validateProjectConfig(opts.config);
         const folder = ProjectFolder(opts.folderUri);
         let project = this.#projects.find(p => p.folder === folder);
@@ -265,7 +312,9 @@ export class ProjectsManager {
             // if there is any project within subfolder or parent folder
             // we need to reset assigned to documents project IDs
             mustReset = this.#projects.some(p => p.folder.startsWith(folder) || folder.startsWith(p.folder));
-            this.#projects = pipe([...this.#projects, project], sortBy([({ folder }) => withoutProtocol(folder).split('/').length, 'desc']));
+            this.#projects = pipe([...this.#projects, project], sortBy(
+            // sort by folder depth (longest first)
+            [({ folder }) => withoutProtocol(folder).split('/').length, 'desc']));
             logger.info `register project ${project.id} folder: ${folder}`;
         }
         else {
@@ -292,11 +341,20 @@ export class ProjectsManager {
             project.exclude = DefaultProject.exclude;
         }
         else if (hasAtLeast(config.exclude, 1)) {
-            project.exclude = picomatch(config.exclude, { dot: true });
+            const patterns = map(config.exclude, p => {
+                if (!isRelative(p) && !p.startsWith('**')) {
+                    p = joinURL('**', p);
+                }
+                return cleanDoubleSlashes(joinRelativeURL(project.folderUri.path, p));
+            });
+            project.exclude = picomatch(patterns, {
+                contains: true,
+                dot: true,
+            });
         }
         // Resolve include paths relative to project folder
         if (project.includeConfig.paths && hasAtLeast(project.includeConfig.paths, 1)) {
-            project.includePaths = project.includeConfig.paths.map(includePath => {
+            project.includePaths = map(project.includeConfig.paths, includePath => {
                 const resolvedPath = joinRelativeURL(project.folderUri.path, includePath);
                 const uri = project.folderUri.with({ path: resolvedPath });
                 return {
@@ -312,6 +370,7 @@ export class ProjectsManager {
                     if (otherProject.id === project.id)
                         continue;
                     if (includePath.folder.startsWith(otherProject.folder) || otherProject.folder.startsWith(includePath.folder)) {
+                        mustReset = true;
                         logger.warn('Project "{projectId}" include path "{includePath}" overlaps with project "{otherProjectId}" folder. ' +
                             'Files in overlapping areas will only belong to one project.', { projectId: project.id, includePath: includePath.folder, otherProjectId: otherProject.id });
                     }
@@ -320,6 +379,7 @@ export class ProjectsManager {
                         for (const otherIncludePath of otherProject.includePaths) {
                             if (includePath.folder.startsWith(otherIncludePath.folder)
                                 || otherIncludePath.folder.startsWith(includePath.folder)) {
+                                mustReset = true;
                                 logger.warn('Project "{projectId}" include path "{includePath}" overlaps with project "{otherProjectId}" ' +
                                     'include path "{otherIncludePath}". Files in overlapping areas will only belong to one project.', {
                                     projectId: project.id,
@@ -337,9 +397,10 @@ export class ProjectsManager {
             delete project.includePaths;
         }
         this.#projectIdToFolder.set(project.id, folder);
+        this.#lookupById.clear();
         // Reset assigned project IDs if no projects reload is active
         if (mustReset && !this.#activeReload) {
-            await this.rebuidProject(project.id).catch(error => {
+            await this.rebuidProject(project.id, cancelToken).catch(error => {
                 logger.warn('Failed to rebuild project {projectId} after config change', {
                     projectId: project.id,
                     error,
@@ -362,11 +423,11 @@ export class ProjectsManager {
         }).id;
     }
     #activeReload = null;
-    async reloadProjects() {
+    async reloadProjects(cancelToken) {
         try {
             if (!this.#activeReload) {
                 logger.debug `schedule reload projects`;
-                this.#activeReload = this._reloadProjects();
+                this.#activeReload = this._reloadProjects(cancelToken);
             }
             else {
                 logger.debug `reload projects is already in progress, waiting`;
@@ -377,49 +438,48 @@ export class ProjectsManager {
             this.#activeReload = null;
         }
     }
-    async _reloadProjects() {
-        // debounce reload projects
-        await delay(200);
+    async _reloadProjects(cancelToken) {
         const folders = this.services.workspace.WorkspaceManager.workspaceFolders;
         if (!folders) {
             logger.warn('No workspace folders found');
             return;
         }
-        await this.services.workspace.WorkspaceLock.write(async (cancelToken) => {
-            logger.debug `start reload projects`;
-            const configFiles = [];
-            for (const folder of folders) {
-                try {
-                    logger.debug `scan projects in folder ${folder.uri}`;
-                    const files = await this.services.workspace.FileSystemProvider.scanProjectFiles(URI.parse(folder.uri));
-                    for (const file of files) {
-                        if (file.isFile && this.isConfigFile(file.uri)) {
-                            logger.debug `found config ${file.uri.fsPath}`;
-                            configFiles.push(file.uri);
-                        }
+        logger.debug `start reload projects`;
+        const configFiles = [];
+        for (const folder of folders) {
+            try {
+                logger.debug `scan projects in folder ${folder.uri}`;
+                const files = await this.services.workspace.FileSystemProvider.scanProjectFiles(URI.parse(folder.uri));
+                for (const file of files) {
+                    if (file.isFile && this.isConfigFile(file.uri)) {
+                        logger.debug `found config ${file.uri.fsPath}`;
+                        configFiles.push(file.uri);
                     }
                 }
-                catch (error) {
-                    logger.error('Failed to scanProjectFiles, {folder}', { folder: folder.uri, error });
-                }
             }
-            if (configFiles.length === 0 && this.#projects.length !== 0) {
-                logger.warning('No config files found, but some projects were registered before');
+            catch (error) {
+                logger.error('Failed to scanProjectFiles, {folder}', { folder: folder.uri, error });
             }
-            await interruptAndCheck(cancelToken);
-            this.#projects = [];
-            this.#projectIdToFolder.clear();
-            for (const uri of configFiles) {
-                try {
-                    await this.registerConfigFile(uri);
-                }
-                catch (error) {
-                    logger.error('Failed to load config file {uri}', { uri: uri.fsPath, 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();
+        this.#lookupById.clear();
+        for (const uri of configFiles) {
+            if (cancelToken) {
+                await interruptAndCheck(cancelToken);
             }
-            this.reset();
-            await this.services.workspace.WorkspaceManager.rebuildAll(cancelToken);
-        });
+            try {
+                await this.registerConfigFile(uri, cancelToken);
+            }
+            catch (error) {
+                logger.error('Failed to load config file {uri}', { uri: uri.fsPath, error });
+            }
+        }
+        this.reset();
+        await this.services.workspace.WorkspaceManager.rebuildAll(cancelToken);
     }
     uniqueProjectId(name) {
         let id = name;
@@ -430,28 +490,18 @@ export class ProjectsManager {
         return id;
     }
     reset() {
+        logger.debug('reset');
         this.#defaultProject = undefined;
         if (this.#defaultProjectId && !this.#projectIdToFolder.has(this.#defaultProjectId)) {
             this.#defaultProjectId = undefined;
         }
-        this.services.workspace.LangiumDocuments.all.forEach(doc => {
-            if (isLikeC4Builtin(doc.uri)) {
-                return;
-            }
-            // Remove assigned project ID to force re-calculation
-            delete doc.likec4ProjectId;
-        });
+        this.services.workspace.LangiumDocuments.resetProjectIds();
         this.documentBelongsTo.clear();
         this.mappingsToProject.clear();
+        this.#lookupById.clear();
         this.#excludedDocuments = new WeakMap();
     }
     async rebuidProject(projectId, cancelToken) {
-        if (!cancelToken) {
-            return await this.services.workspace.WorkspaceLock.write(async (ct) => {
-                await this.rebuidProject(projectId, ct);
-            });
-        }
-        logger.info `rebuild project ${projectId}`;
         // reset default project cache
         this.#defaultProject = undefined;
         const project = this.#projects.find(p => p.id === projectId) ?? this.default;
@@ -460,18 +510,18 @@ export class ProjectsManager {
         }
         const log = logger.getChild(project.id);
         const folder = project.folder;
-        const includePathStrings = project.includePaths?.map(p => p.folder) ?? [];
+        const includePaths = project.includePaths;
         const docs = this.services.workspace.LangiumDocuments
             .all
             .filter(doc => {
             if (project.exclude?.(doc.uri.path)) {
                 return false;
             }
-            const docUriStr = doc.uri.toString();
+            const docUriStr = normalizeUri(doc.uri);
             if (docUriStr.startsWith(folder)) {
                 return true;
             }
-            if (includePathStrings.some(includePath => docUriStr.startsWith(includePath))) {
+            if (includePaths && includePaths.some(isParentFolderFor(docUriStr))) {
                 return true;
             }
             const docdir = withTrailingSlash(joinRelativeURL(docUriStr, '..'));
@@ -480,10 +530,10 @@ export class ProjectsManager {
             .map(d => d.uri)
             .toArray();
         if (docs.length > 0) {
-            this.reset();
-            log.info('rebuild documents: {docs}', {
+            log.info('rebuild project documents: {docs}', {
                 docs: docs.length,
             });
+            this.reset();
             await this.services.workspace.DocumentBuilder
                 .update(docs, [], cancelToken)
                 .catch(error => {
@@ -492,23 +542,22 @@ export class ProjectsManager {
                 });
             });
         }
+        else {
+            log.debug('no documents in project, skipping rebuild');
+        }
     }
     findProjectForDocument(documentUri) {
         return this.mappingsToProject.get(documentUri, () => {
-            const project = this.#projects.find(({ folder }) => documentUri.startsWith(folder));
+            const hasThisDoc = isParentFolderFor(documentUri);
+            const project = this.#projects.find(hasThisDoc);
             if (project) {
                 return project;
             }
-            const projectWithInclude = this.#projects.find(({ includePaths }) => {
-                if (!includePaths)
-                    return false;
-                return includePaths.some(includePath => documentUri.startsWith(includePath.folder));
+            const projectIncludingThisDoc = this.#projects.find(({ includePaths }) => {
+                return !!includePaths && includePaths.some(hasThisDoc);
             });
-            if (projectWithInclude) {
-                return projectWithInclude;
-            }
             // If the document is not part of any project, assign it to the global project ID
-            return this.default;
+            return projectIncludingThisDoc ?? this.default;
         });
     }
     // The mapping between document URIs and their corresponding project ID
@@ -553,3 +602,4 @@ export class ProjectsManager {
         }
     }
 }
+_a = ProjectsManager;

package/dist/workspace/WorkspaceManager.d.ts

@@ -1,6 +1,6 @@
 import type { BuildOptions, Cancellation, FileSelector, FileSystemNode, LangiumDocument, LangiumDocumentFactory } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
-import type { WorkspaceFolder } from 'vscode-languageserver';
+import { type WorkspaceFolder } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import type { FileSystemProvider } from '../filesystem';
 import type { LikeC4SharedServices } from '../module';

package/dist/workspace/WorkspaceManager.js

@@ -1,6 +1,7 @@
 import { invariant } from '@likec4/core';
 import { DefaultWorkspaceManager } from 'langium';
 import { hasAtLeast } from 'remeda';
+import { CancellationToken } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import * as BuiltIn from '../likec4lib';
 import { logger, logWarnError } from '../logger';
@@ -39,7 +40,7 @@ export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
         const projects = this.services.workspace.ProjectsManager;
         for (const entry of configFiles) {
             try {
-                await projects.registerConfigFile(entry.uri);
+                await projects.registerConfigFile(entry.uri, CancellationToken.None);
             }
             catch (error) {
                 logWarnError(error);
@@ -113,11 +114,6 @@ export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
         return null;
     }
     async rebuildAll(cancelToken) {
-        if (!cancelToken) {
-            return await this.services.workspace.WorkspaceLock.write(async (ct) => {
-                await this.rebuildAll(ct);
-            });
-        }
         const docs = this.services.workspace.LangiumDocuments.all.map(d => d.uri).toArray();
         logger.info('invalidate and rebuild all {docs} documents', { docs: docs.length });
         this.services.workspace.Cache.clear();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.46.2",
+  "version": "1.46.4",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -76,7 +76,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@hpcc-js/wasm-graphviz": "1.16.0",
+    "@hpcc-js/wasm-graphviz": "1.17.0",
     "bundle-require": "^5.1.0",
     "esbuild": "0.27.1"
   },
@@ -86,14 +86,14 @@
     "@msgpack/msgpack": "^3.1.2",
     "@smithy/util-base64": "^4.3.0",
     "@types/natural-compare-lite": "^1.4.2",
-    "@types/node": "~22.19.1",
+    "@types/node": "~22.19.3",
     "@types/picomatch": "^4.0.2",
     "@types/vscode": "^1.106.1",
     "@types/which": "^3.0.4",
-    "chokidar": "^4.0.3",
+    "chokidar": "^5.0.0",
     "defu": "^6.1.4",
     "esm-env": "^1.2.2",
-    "fast-equals": "^5.3.3",
+    "fast-equals": "^5.4.0",
     "fdir": "6.4.0",
     "fetch-to-node": "^2.1.0",
     "hono": "^4.11.1",
@@ -102,7 +102,7 @@
     "json5": "^2.2.3",
     "langium": "3.5.0",
     "langium-cli": "3.5.2",
-    "nano-spawn": "^1.0.3",
+    "nano-spawn": "^2.0.0",
     "natural-compare-lite": "^1.4.0",
     "oxlint": "1.33.0",
     "p-debounce": "4.0.0",
@@ -126,13 +126,13 @@
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
     "zod": "^3.25.76",
-    "@likec4/config": "1.46.2",
-    "@likec4/layouts": "1.46.2",
+    "@likec4/config": "1.46.4",
+    "@likec4/core": "1.46.4",
+    "@likec4/devops": "1.42.0",
+    "@likec4/icons": "1.46.4",
     "@likec4/log": "1.46.1",
-    "@likec4/icons": "1.46.1",
-    "@likec4/core": "1.46.2",
-    "@likec4/tsconfig": "1.46.1",
-    "@likec4/devops": "1.42.0"
+    "@likec4/layouts": "1.46.4",
+    "@likec4/tsconfig": "1.46.1"
   },
   "scripts": {
     "typecheck": "tsc -b --verbose",