@likec4/language-server 1.43.0 → 1.45.0

package/dist/workspace/LangiumDocuments.d.ts

@@ -1,18 +1,19 @@
 import type { NonEmptyArray, ProjectId } from '@likec4/core';
-import type { LangiumDocument, Stream } from 'langium';
+import type { LangiumDocument, Stream, URI } from 'langium';
 import { DefaultLangiumDocuments } from 'langium';
 import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4SharedServices } from '../module';
 export declare class LangiumDocuments extends DefaultLangiumDocuments {
     protected services: LikeC4SharedServices;
-    protected compare: any;
+    protected compare: (a: string | undefined, b: string | undefined) => number;
     constructor(services: LikeC4SharedServices);
     addDocument(document: LangiumDocument): void;
+    getDocument(uri: URI): LikeC4LangiumDocument | undefined;
+    get all(): Stream<LikeC4LangiumDocument>;
     /**
      * Returns all user documents, excluding built-in documents.
      */
     get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
     projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
     groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
-    resetProjectIds(): void;
 }

package/dist/workspace/LangiumDocuments.js

@@ -0,0 +1,72 @@
+import { compareNaturalHierarchically } from '@likec4/core/utils';
+import { DefaultLangiumDocuments, stream } from 'langium';
+import { groupBy, prop } from 'remeda';
+import { isLikeC4LangiumDocument } from '../ast';
+import { LikeC4LanguageMetaData } from '../generated/module';
+import { isLikeC4Builtin } from '../likec4lib';
+/**
+ * Compare function for document paths to ensure consistent order
+ */
+const compare = compareNaturalHierarchically('/', true);
+const ensureOrder = (a, b) => compare(a.uri.path, b.uri.path);
+const exclude = (doc) => {
+    return doc.textDocument.languageId !== LikeC4LanguageMetaData.languageId || isLikeC4Builtin(doc.uri);
+};
+export class LangiumDocuments extends DefaultLangiumDocuments {
+    services;
+    compare = compareNaturalHierarchically('/', true);
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    addDocument(document) {
+        const uriString = document.uri.toString();
+        if (this.documentMap.has(uriString)) {
+            throw new Error(`A document with the URI '${uriString}' is already present.`);
+        }
+        const docs = [...this.documentMap.values(), document].sort(ensureOrder);
+        // Clear and re-add documents to ensure consistent order
+        this.documentMap.clear();
+        for (const doc of docs) {
+            this.documentMap.set(doc.uri.toString(), doc);
+        }
+    }
+    getDocument(uri) {
+        const doc = super.getDocument(uri);
+        if (doc && !exclude(doc)) {
+            doc.likec4ProjectId ??= this.services.workspace.ProjectsManager.belongsTo(doc);
+        }
+        if (doc && !isLikeC4LangiumDocument(doc)) {
+            throw new Error(`Document ${doc.uri.path} is not a LikeC4 document`);
+        }
+        return doc;
+    }
+    get all() {
+        return stream(this.documentMap.values())
+            .filter((doc) => {
+            if (doc.textDocument.languageId === LikeC4LanguageMetaData.languageId) {
+                if (!isLikeC4Builtin(doc.uri)) {
+                    doc.likec4ProjectId ??= this.services.workspace.ProjectsManager.belongsTo(doc);
+                }
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * Returns all user documents, excluding built-in documents.
+     */
+    get allExcludingBuiltin() {
+        const projects = this.services.workspace.ProjectsManager;
+        return super.all.filter((doc) => {
+            // Exclude built-in and non-LikeC4 documents, and also documents excluded by ProjectsManager
+            return !exclude(doc) && !projects.isExcluded(doc);
+        });
+    }
+    projectDocuments(projectId) {
+        return this.allExcludingBuiltin.filter(doc => doc.likec4ProjectId === projectId);
+    }
+    groupedByProject() {
+        return groupBy(this.allExcludingBuiltin.toArray(), prop('likec4ProjectId'));
+    }
+}

package/dist/workspace/ProjectsManager.d.ts

@@ -1,6 +1,6 @@
 import { type LikeC4ProjectConfig, type LikeC4ProjectConfigInput } from '@likec4/config';
 import type { NonEmptyReadonlyArray } from '@likec4/core';
-import type { scalar } from '@likec4/core/types';
+import type { ProjectId, scalar } from '@likec4/core/types';
 import { type Cancellation, type LangiumDocument, URI, WorkspaceCache } from 'langium';
 import type { Tagged } from 'type-fest';
 import type { LikeC4SharedServices } from '../module';
@@ -29,7 +29,7 @@ export declare class ProjectsManager {
      * The global project ID used for all documents
      * that are not part of a specific project.
      */
-    static readonly DefaultProjectId: scalar.ProjectId;
+    static readonly DefaultProjectId: ProjectId<string>;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns:
@@ -40,6 +40,7 @@ export declare class ProjectsManager {
      */
     get defaultProjectId(): scalar.ProjectId | undefined;
     set defaultProjectId(id: string | scalar.ProjectId | undefined);
+    get default(): ProjectData;
     get all(): NonEmptyReadonlyArray<scalar.ProjectId>;
     getProject(arg: scalar.ProjectId | LangiumDocument): Project;
     /**
@@ -48,11 +49,15 @@ export declare class ProjectsManager {
      * If there are multiple projects and default project is not set, throws an error
      */
     ensureProjectId(projectId?: scalar.ProjectId | undefined): scalar.ProjectId;
+    /**
+     * Validates and ensures the project.
+     */
+    ensureProject(projectId?: scalar.ProjectId | undefined): Project;
     hasMultipleProjects(): boolean;
     /**
      * Checks if the specified document should be excluded from processing.
      */
-    checkIfExcluded(document: LangiumDocument | URI | string): boolean;
+    isExcluded(document: LangiumDocument | URI | string): boolean;
     /**
      * Checks if it is a config file and it is not excluded by default exclude pattern
      *
@@ -60,30 +65,34 @@ export declare class ProjectsManager {
      */
     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
+     * Registers likec4 project by config file.
      */
-    registerConfigFile(configFile: URI): Promise<ProjectData | undefined>;
+    registerConfigFile(configFile: URI): Promise<ProjectData>;
     /**
      * Registers (or reloads) likec4 project by config file or config object.
      * If there is some project registered at same folder, it will be reloaded.
      */
-    registerProject(opts: URI | {
-        config: LikeC4ProjectConfigInput;
+    registerProject(opts: {
+        config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
         folderUri: URI | string;
     }): Promise<ProjectData>;
     /**
-     * Registers (or reloads) likec4 project by config file or config object.
-     * If there is some project registered at same folder, it will be reloaded.
+     * Determines which project the given document belongs to.
+     * If the document does not belong to any project, returns the default project ID.
      */
-    private _registerProject;
     belongsTo(document: LangiumDocument | URI | string): scalar.ProjectId;
     reloadProjects(): Promise<void>;
+    protected _reloadProjects(): Promise<void>;
     protected uniqueProjectId(name: string): scalar.ProjectId;
-    protected resetProjectIds(): void;
-    protected rebuidDocuments(cancelToken?: Cancellation.CancellationToken): Promise<void>;
-    protected findProjectForDocument(documentUri: string): any;
-    protected get mappingsToProject(): WorkspaceCache<string, Pick<ProjectData, 'id' | 'config' | 'exclude'>>;
+    protected reset(): void;
+    rebuidProject(projectId: ProjectId, cancelToken?: Cancellation.CancellationToken): Promise<void>;
+    protected findProjectForDocument(documentUri: string): ProjectData;
+    protected get mappingsToProject(): WorkspaceCache<string, ProjectData>;
+    /**
+     * The mapping between documents and projects they belong to.
+     * Lazy-created due to initialization order of the LanguageServer
+     */
+    protected get documentBelongsTo(): WorkspaceCache<LangiumDocument, ProjectData>;
+    private getWorkspaceFolder;
 }
 export {};

package/dist/workspace/ProjectsManager.js

@@ -0,0 +1,469 @@
+import { isLikeC4Config, validateProjectConfig, } from '@likec4/config';
+import { BiMap, delay, 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 { logger as mainLogger } from '../logger';
+const logger = mainLogger.getChild('ProjectsManager');
+function normalizeUri(uri) {
+    if (URI.isUri(uri)) {
+        return uri.toString();
+    }
+    else if (typeof uri === 'string') {
+        // TODO: handle non-file URIs, i.e. vscode-remote://
+        return uri.startsWith('file://') ? uri : URI.file(uri).toString();
+    }
+    else {
+        return uri.uri.toString();
+    }
+}
+export function ProjectFolder(folder) {
+    folder = normalizeUri(folder);
+    return withTrailingSlash(folder);
+}
+const DefaultProject = {
+    id: 'default',
+    config: {
+        name: 'default',
+        exclude: ['**/node_modules/**'],
+    },
+    exclude: picomatch('**/node_modules/**', { dot: true }),
+};
+export class ProjectsManager {
+    services;
+    /**
+     * The global project ID used for all documents
+     * that are not part of a specific project.
+     */
+    static DefaultProjectId = DefaultProject.id;
+    /**
+     * Configured default project ID.
+     * (it is used in CLI and Vite plugin)
+     */
+    #defaultProjectId = undefined;
+    /**
+     * Cached default project.
+     */
+    #defaultProject = undefined;
+    /**
+     * The mapping between project config files and project IDs.
+     */
+    #projectIdToFolder = new BiMap();
+    /**
+     * 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 = [];
+    #excludedDocuments = new WeakMap();
+    constructor(services) {
+        this.services = services;
+        logger.debug `created`;
+    }
+    /**
+     * Returns:
+     *  - configured default project ID if set
+     *  - the default project ID if there are no projects.
+     *  - the ID of the only project
+     *  - undefined if there are multiple projects.
+     */
+    get defaultProjectId() {
+        if (this.#defaultProjectId) {
+            return this.#defaultProjectId;
+        }
+        if (this.#projects.length > 1) {
+            return undefined;
+        }
+        return this.#projects[0]?.id ?? ProjectsManager.DefaultProjectId;
+    }
+    set defaultProjectId(id) {
+        if (id === this.#defaultProjectId) {
+            return;
+        }
+        this.#defaultProject = undefined;
+        if (!id || id === ProjectsManager.DefaultProjectId) {
+            logger.debug `reset default project ID`;
+            this.#defaultProjectId = undefined;
+            return;
+        }
+        invariant(this.#projects.find(p => p.id === id), `Project "${id}" not found`);
+        logger.debug `set default project ID to ${id}`;
+        this.#defaultProjectId = id;
+    }
+    get default() {
+        if (!this.#defaultProject) {
+            const id = this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
+            let project = this.#projects.find(p => p.id === id);
+            if (!project) {
+                const folderUri = this.getWorkspaceFolder();
+                project = {
+                    id,
+                    config: DefaultProject.config,
+                    folder: ProjectFolder(folderUri),
+                    folderUri,
+                    exclude: DefaultProject.exclude,
+                };
+            }
+            this.#defaultProject = project;
+        }
+        return this.#defaultProject;
+    }
+    get all() {
+        if (hasAtLeast(this.#projects, 1)) {
+            const ids = [
+                ...map(this.#projects, prop('id')),
+                DefaultProject.id,
+            ];
+            // if default project is set, ensure it is first
+            if (this.#defaultProjectId) {
+                const idx = ids.findIndex(p => p === this.#defaultProjectId);
+                if (idx > 0) {
+                    const [defaultProject] = ids.splice(idx, 1);
+                    return [defaultProject, ...ids];
+                }
+            }
+            return ids;
+        }
+        return [DefaultProject.id];
+    }
+    getProject(arg) {
+        const id = typeof arg === 'string' ? arg : (arg.likec4ProjectId || this.belongsTo(arg));
+        if (id === DefaultProject.id) {
+            let folderUri;
+            try {
+                folderUri = this.services.workspace.WorkspaceManager.workspaceUri;
+            }
+            catch (error) {
+                logger.warn('Failed to get workspace URI, using default folder', { error });
+                folderUri = URI.file('/');
+                // ignore - workspace not initialized
+            }
+            return {
+                id: ProjectsManager.DefaultProjectId,
+                config: DefaultProject.config,
+                folderUri,
+            };
+        }
+        const { config, folderUri, } = nonNullable(this.#projects.find(p => p.id === id), `Project "${id}" not found`);
+        return {
+            id,
+            folderUri,
+            config,
+        };
+    }
+    /**
+     * Validates and ensures the project ID.
+     * If no project ID is specified, returns default project ID
+     * 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) {
+            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(', ')}]`);
+    }
+    /**
+     * Validates and ensures the project.
+     */
+    ensureProject(projectId) {
+        projectId = this.ensureProjectId(projectId);
+        return this.getProject(projectId);
+    }
+    hasMultipleProjects() {
+        return this.#projects.length > 1;
+    }
+    /**
+     * Checks if the specified document should be excluded from processing.
+     */
+    isExcluded(document) {
+        if (typeof document === 'string' || URI.isUri(document)) {
+            let docUriAsString = normalizeUri(document);
+            const project = this.findProjectForDocument(docUriAsString);
+            return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+        }
+        let isExcluded = this.#excludedDocuments.get(document);
+        if (isExcluded === undefined) {
+            isExcluded = this.isExcluded(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.toString(), { strict: false })?.toLowerCase();
+        const isConfigFile = !!filename && isLikeC4Config(filename);
+        if (isConfigFile) {
+            if (DefaultProject.exclude(entry.path)) {
+                logger.debug `exclude config file ${entry.path}`;
+                return false;
+            }
+        }
+        return isConfigFile;
+    }
+    /**
+     * Registers likec4 project by config file.
+     */
+    async registerConfigFile(configFile) {
+        if (DefaultProject.exclude(configFile.path)) {
+            throw new Error(`Path to ${configFile.fsPath} is excluded by: ${DefaultProject.config.exclude.join(', ')}`);
+        }
+        if (!this.isConfigFile(configFile)) {
+            throw new Error(`${configFile.fsPath} is not a valid LikeC4 config filename.`);
+        }
+        try {
+            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 });
+        }
+        catch (error) {
+            this.services.lsp.Connection?.window.showErrorMessage(`LikeC4: Failed to register project at ${configFile.fsPath}`);
+            throw wrapError(error, `Failed to register project config ${configFile.fsPath}:\n`);
+        }
+    }
+    /**
+     * 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) {
+        const config = validateProjectConfig(opts.config);
+        const folder = ProjectFolder(opts.folderUri);
+        let project = this.#projects.find(p => p.folder === folder);
+        if (project && deepEqual(project.config, config)) {
+            return project;
+        }
+        let mustReset = false;
+        let id;
+        if (!project) {
+            if (this.#projectIdToFolder.has(config.name)) {
+                logger.warn `Project "${config.name}" already exists, generating unique ID`;
+            }
+            id = this.uniqueProjectId(config.name);
+            project = {
+                id,
+                config,
+                folder,
+                folderUri: URI.parse(folder),
+            };
+            // 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']));
+            logger.info `register project ${project.id} folder: ${folder}`;
+        }
+        else {
+            // Project exists but configs are different (deepEqual check above)
+            mustReset = true;
+            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;
+        }
+        // Reset cached default project
+        this.#defaultProject = undefined;
+        if (isNullish(config.exclude)) {
+            project.exclude = DefaultProject.exclude;
+        }
+        else if (hasAtLeast(config.exclude, 1)) {
+            project.exclude = picomatch(config.exclude, { dot: true });
+        }
+        this.#projectIdToFolder.set(project.id, folder);
+        // Reset assigned project IDs if no projects reload is active
+        if (mustReset && !this.#activeReload) {
+            await this.rebuidProject(project.id).catch(error => {
+                logger.warn('Failed to rebuild project {projectId} after config change', {
+                    projectId: project.id,
+                    error,
+                });
+            });
+        }
+        return project;
+    }
+    /**
+     * Determines which project the given document belongs to.
+     * If the document does not belong to any project, returns the default project ID.
+     */
+    belongsTo(document) {
+        if (URI.isUri(document) || typeof document === 'string') {
+            const documentUri = normalizeUri(document);
+            return this.findProjectForDocument(documentUri).id;
+        }
+        return this.documentBelongsTo.get(document, () => {
+            return this.findProjectForDocument(normalizeUri(document.uri));
+        }).id;
+    }
+    #activeReload = null;
+    async reloadProjects() {
+        try {
+            if (!this.#activeReload) {
+                logger.debug `schedule reload projects`;
+                this.#activeReload = this._reloadProjects();
+            }
+            else {
+                logger.debug `reload projects is already in progress, waiting`;
+            }
+            await this.#activeReload;
+        }
+        finally {
+            this.#activeReload = null;
+        }
+    }
+    async _reloadProjects() {
+        // debounce reload projects
+        await delay(200);
+        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);
+                        }
+                    }
+                }
+                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');
+            }
+            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 });
+                }
+            }
+            this.reset();
+            await this.services.workspace.WorkspaceManager.rebuildAll(cancelToken);
+        });
+    }
+    uniqueProjectId(name) {
+        let id = name;
+        let i = 1;
+        while (this.#projectIdToFolder.has(id)) {
+            id = `${name}-${i++}`;
+        }
+        return id;
+    }
+    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.documentBelongsTo.clear();
+        this.mappingsToProject.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);
+            });
+        }
+        // reset default project cache
+        this.#defaultProject = undefined;
+        const project = this.#projects.find(p => p.id === projectId) ?? this.default;
+        const folder = project.folder;
+        const docs = this.services.workspace.LangiumDocuments
+            .all
+            .filter(doc => {
+            if (project.exclude?.(doc.uri.path)) {
+                return false;
+            }
+            if (doc.uri.toString().startsWith(folder)) {
+                return true;
+            }
+            const docdir = withTrailingSlash(joinRelativeURL(doc.uri.toString(), '..'));
+            return docdir.startsWith(folder) || folder.startsWith(docdir);
+        })
+            .map(d => d.uri)
+            .toArray();
+        if (docs.length > 0) {
+            this.reset();
+            const projectId = project.id;
+            logger.info('rebuild documents of project {projectId}: {docs}', {
+                projectId,
+                docs: docs.length,
+            });
+            await this.services.workspace.DocumentBuilder
+                .update(docs, [], cancelToken)
+                .catch(error => {
+                logger.warn('Failed to rebuild project {projectId}', {
+                    projectId,
+                    error,
+                });
+            });
+        }
+    }
+    findProjectForDocument(documentUri) {
+        return this.mappingsToProject.get(documentUri, () => {
+            const project = this.#projects.find(({ folder }) => documentUri.startsWith(folder));
+            // If the document is not part of any project, assign it to the global project ID
+            return project ?? this.default;
+        });
+    }
+    // The mapping between document URIs and their corresponding project ID
+    // Lazy-created due to initialization order of the LanguageServer
+    get mappingsToProject() {
+        return memoizeProp(this, '_mappingsToProject', () => new WorkspaceCache(this.services));
+    }
+    /**
+     * The mapping between documents and projects they belong to.
+     * Lazy-created due to initialization order of the LanguageServer
+     */
+    get documentBelongsTo() {
+        return memoizeProp(this, '_documentBelongsTo', () => new WorkspaceCache(this.services));
+    }
+    getWorkspaceFolder() {
+        try {
+            return this.services.workspace.WorkspaceManager.workspaceUri;
+        }
+        catch (error) {
+            logger.warn('Failed to get workspace URI, using default folder', { error });
+            return URI.file('/');
+            // ignore - workspace not initialized
+        }
+    }
+}

package/dist/workspace/WorkspaceManager.d.ts

@@ -1,4 +1,4 @@
-import type { BuildOptions, FileSelector, FileSystemNode, LangiumDocument, LangiumDocumentFactory } from 'langium';
+import type { BuildOptions, Cancellation, FileSelector, FileSystemNode, LangiumDocument, LangiumDocumentFactory } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
 import type { WorkspaceFolder } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
@@ -24,7 +24,8 @@ export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      * Determine whether the given folder entry shall be included while indexing the workspace.
      */
     protected includeEntry(_workspaceFolder: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
-    workspace(): any;
+    workspace(): WorkspaceFolder | null;
+    rebuildAll(cancelToken?: Cancellation.CancellationToken): Promise<void>;
     get workspaceUri(): URI;
     get workspaceURL(): URL;
 }