@likec4/language-server 1.43.0 → 1.44.0

package/dist/views/ConfigurableLayouter.js

@@ -0,0 +1,51 @@
+import { GraphvizWasmAdapter, QueueGraphvizLayoter } from '@likec4/layouts';
+import { GraphvizBinaryAdapter } from '@likec4/layouts/graphviz/binary';
+import { isEmpty } from 'remeda';
+import which from 'which';
+import { logger } from '../logger';
+function graphvizBinPath() {
+    try {
+        return which.sync('dot');
+    }
+    catch (error) {
+        logger.error('Error checking for native Graphviz:', { error });
+        return null;
+    }
+}
+export const ConfigurableLayouter = {
+    likec4: {
+        Layouter(services) {
+            logger.debug('Creating ConfigurableLayouter');
+            const layouter = new QueueGraphvizLayoter();
+            services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
+                logger.debug('Configuration update: {update}', { update });
+                if (update.section !== services.LanguageMetaData.languageId) {
+                    logger.debug(`Ignoring configuration update as it is not for ${services.LanguageMetaData.languageId}`);
+                    return;
+                }
+                try {
+                    const { mode, path } = update.configuration.graphviz ?? {
+                        mode: 'wasm',
+                        path: '',
+                    };
+                    if (mode !== 'wasm') {
+                        let binaryPath = isEmpty(path) ? graphvizBinPath() : path;
+                        if (!isEmpty(binaryPath)) {
+                            layouter.changePort(new GraphvizBinaryAdapter(binaryPath));
+                            logger.info `use graphviz binary: ${binaryPath}`;
+                            return;
+                        }
+                        logger.warn(`No Graphviz binaries found on PATH, use graphviz wasm`);
+                        services.shared.lsp.Connection?.window.showWarningMessage('No Graphviz binaries found on PATH, set path to binaries in settings.');
+                    }
+                    layouter.changePort(new GraphvizWasmAdapter());
+                    logger.info('use graphviz wasm');
+                }
+                catch (error) {
+                    logger.error('Failed to update configuration', { error });
+                }
+            });
+            return layouter;
+        },
+    },
+};

package/dist/views/LikeC4ManualLayouts.d.ts

@@ -0,0 +1,28 @@
+import type { LayoutedView, ViewId } from '@likec4/core';
+import { type Location } from 'vscode-languageserver-types';
+import type { LikeC4Services } from '../module';
+import type { Project } from '../workspace/ProjectsManager';
+/**
+ * @todo sync with vscode extension watchers
+ *       (search for ".likec4.snap" references)
+ */
+export declare const isManualLayoutFile: (path: string) => boolean;
+export interface LikeC4ManualLayouts {
+    read(project: Project): Promise<Record<ViewId, LayoutedView> | null>;
+    write(project: Project, layouted: LayoutedView): Promise<Location>;
+    remove(project: Project, view: ViewId): Promise<Location | null>;
+    clearCaches(): void;
+}
+export interface LikeC4ManualLayoutsModuleContext {
+    manualLayouts: (services: LikeC4Services) => LikeC4ManualLayouts;
+}
+export declare const WithLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
+export declare class DefaultLikeC4ManualLayouts implements LikeC4ManualLayouts {
+    private services;
+    private manualLayouts;
+    constructor(services: LikeC4Services);
+    read(project: Project): Promise<Record<ViewId, LayoutedView> | null>;
+    write(project: Project, layouted: LayoutedView): Promise<Location>;
+    remove(project: Project, view: ViewId): Promise<Location | null>;
+    clearCaches(): void;
+}

package/dist/views/LikeC4ManualLayouts.js

@@ -0,0 +1,132 @@
+import { getOrCreate } from '@likec4/core/utils';
+import JSON5 from 'json5';
+import { UriUtils } from 'langium';
+import { indexBy, prop } from 'remeda';
+import { Position, Range, } from 'vscode-languageserver-types';
+import { logger as rootLogger } from '../logger';
+const logger = rootLogger.getChild('manual-layouts');
+/**
+ * @todo sync with vscode extension watchers
+ *       (search for ".likec4.snap" references)
+ */
+export const isManualLayoutFile = (path) => path.endsWith('.likec4.snap');
+function fileName(view) {
+    return `${view}.likec4.snap`;
+}
+function getManualLayoutsOutDir(project) {
+    return UriUtils.resolvePath(project.folderUri, project.config.manualLayouts?.outDir ?? '.likec4');
+}
+export const WithLikeC4ManualLayouts = {
+    manualLayouts: (services) => new DefaultLikeC4ManualLayouts(services),
+};
+export class DefaultLikeC4ManualLayouts {
+    services;
+    manualLayouts = new WeakMap();
+    constructor(services) {
+        this.services = services;
+    }
+    async read(project) {
+        return await getOrCreate(this.manualLayouts, project.folderUri, async (_) => {
+            const fs = this.services.shared.workspace.FileSystemProvider;
+            const outDir = getManualLayoutsOutDir(project);
+            const manualLayouts = [];
+            try {
+                const files = await fs.scanDirectory(outDir, isManualLayoutFile);
+                if (files.length === 0) {
+                    return null;
+                }
+                for (const file of files) {
+                    if (file.isFile) {
+                        try {
+                            const content = await fs.readFile(file.uri);
+                            manualLayouts.push({
+                                ...JSON5.parse(content),
+                                _layout: 'manual',
+                            });
+                        }
+                        catch (err) {
+                            logger.warn(`Failed to read view snapshot ${file.uri.fsPath}`, { err });
+                        }
+                    }
+                }
+                if (manualLayouts.length) {
+                    logger.debug `read manual layouts for ${project.id}, found ${manualLayouts.length}`;
+                }
+            }
+            catch (err) {
+                logger.warn(`Failed to read manual layouts for ${project.folderUri.fsPath}`, { err });
+            }
+            if (manualLayouts.length === 0) {
+                return null;
+            }
+            return indexBy(manualLayouts, prop('id'));
+        });
+    }
+    async write(project, layouted) {
+        const outDir = getManualLayoutsOutDir(project);
+        const file = UriUtils.joinPath(outDir, fileName(layouted.id));
+        // Ensure the manualLayout field is omitted (may exist in migration)
+        if ('manualLayout' in layouted) {
+            const { manualLayout: _, ...rest } = layouted;
+            layouted = rest;
+        }
+        const content = JSON5.stringify(layouted, {
+            space: 2,
+            quote: '\'',
+        });
+        const location = {
+            uri: file.toString(),
+            range: Range.create(Position.create(0, 0), Position.create(content.split('\n').length - 1, 1)),
+        };
+        logger.debug `write snapshot of ${layouted.id} in project ${project.id} to ${file.fsPath}`;
+        const fs = this.services.shared.workspace.FileSystemProvider;
+        try {
+            await fs.writeFile(file, content);
+        }
+        catch (err) {
+            logger.warn(`Failed to write snapshot ${layouted.id} to ${file.fsPath}`, { err });
+        }
+        const projectCaches = await this.read(project);
+        if (projectCaches) {
+            logger.debug `update snapshot cache of ${layouted.id} in project ${project.id}`;
+            projectCaches[layouted.id] = layouted;
+        }
+        else {
+            this.manualLayouts.delete(project.folderUri);
+        }
+        this.services.likec4.ModelBuilder.clearCache();
+        return location;
+    }
+    async remove(project, view) {
+        const outDir = getManualLayoutsOutDir(project);
+        const file = UriUtils.joinPath(outDir, fileName(view));
+        logger.debug `delete snapshot of ${view} in project ${project.id}. File: ${file.fsPath}`;
+        const location = {
+            uri: file.toString(),
+            range: Range.create(0, 0, 0, 0),
+        };
+        try {
+            const fs = this.services.shared.workspace.FileSystemProvider;
+            if (!(await fs.deleteFile(file))) {
+                logger.warn `Snapshot ${view} did not exist at ${file.fsPath}`;
+                return null;
+            }
+        }
+        catch (err) {
+            logger.warn(`Failed to delete snapshot ${view} from ${file.fsPath}`, { err });
+        }
+        const projectCaches = await this.read(project);
+        if (projectCaches) {
+            logger.debug `clean cache of ${view} in project ${project.id}`;
+            delete projectCaches[view];
+        }
+        else {
+            this.manualLayouts.delete(project.folderUri);
+        }
+        this.services.likec4.ModelBuilder.clearCache();
+        return location;
+    }
+    clearCaches() {
+        this.manualLayouts = new WeakMap();
+    }
+}

package/dist/views/{likec4-views.d.ts → LikeC4Views.d.ts}

@@ -1,10 +1,10 @@
-import type { ComputedView, DiagramView, ProjectId, ViewId } from '@likec4/core';
+import type { ComputedView, DiagramView, LayoutedView, ProjectId, ViewId } from '@likec4/core';
 import { type QueueGraphvizLayoter, GraphvizLayouter } from '@likec4/layouts';
 import type { CancellationToken } from 'vscode-languageserver';
 import type { LikeC4Services } from '../module';
 export type GraphvizOut = {
     readonly dot: string;
-    readonly diagram: DiagramView;
+    readonly diagram: LayoutedView;
 };
 type GraphvizSvgOut = {
     readonly id: ViewId;
@@ -18,17 +18,17 @@ export interface LikeC4Views {
      */
     computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
     /**
-     * Returns all layouted views (i.e. views with layout computed)
-     * Result includes dot and diagram
+     * Returns all layouted views (without manual layout)
      */
     layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut[]>;
     /**
-     * Returns layouted view (i.e. view with layout computed)
-     * Result includes dot and diagram
+     * Layouts a view (from sources, i.e. without manual layout)
+     * If view not found in model, but there is a snapshot - it will be returned (with empty DOT)
      */
     layoutView(viewId: ViewId, projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut | null>;
     /**
-     * Returns diagrams (i.e. views with layout computed)
+     * Returns diagrams.
+     * If diagram has manual layout, it will be used.
      */
     diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
     /**
@@ -53,9 +53,10 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
     constructor(services: LikeC4Services);
     get layouter(): QueueGraphvizLayoter;
     computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
+    private _layoutAllViews;
     layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut[]>;
     layoutView(viewId: ViewId, projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut | null>;
-    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
+    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<LayoutedView>>;
     viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
     /**
      * Open a view in the preview panel.

package/dist/views/LikeC4Views.js

@@ -0,0 +1,200 @@
+import { applyLayoutDriftReasons, applyManualLayout } from '@likec4/core/model';
+import { GraphvizLayouter } from '@likec4/layouts';
+import { loggable } from '@likec4/log';
+import { interruptAndCheck } from 'langium';
+import { unique, values } from 'remeda';
+import { logger as rootLogger, logWarnError } from '../logger';
+import { performanceMark } from '../utils';
+const viewsLogger = rootLogger.getChild('views');
+export class DefaultLikeC4Views {
+    services;
+    cache = new WeakMap();
+    /**
+     * Set of viewIds with reported errors
+     * value is `${projectId}-${viewId}`
+     */
+    viewsWithReportedErrors = new Set();
+    ModelBuilder;
+    constructor(services) {
+        this.services = services;
+        this.ModelBuilder = services.likec4.ModelBuilder;
+    }
+    get layouter() {
+        return this.services.likec4.Layouter;
+    }
+    async computedViews(projectId, cancelToken) {
+        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        return values(likeC4Model.$data.views);
+    }
+    async _layoutAllViews(likeC4Model, cancelToken) {
+        const views = values(likeC4Model.$data.views);
+        if (views.length === 0) {
+            return [];
+        }
+        const m0 = performanceMark();
+        const projectId = likeC4Model.project.id;
+        const logger = viewsLogger.getChild(projectId);
+        logger.debug `layoutAll: ${views.length} views`;
+        const tasks = [];
+        const styles = likeC4Model.$styles;
+        const results = [];
+        //
+        for (const view of views) {
+            let cached = this.cache.get(view);
+            if (cached) {
+                logger.debug `layout ${view.id} from cache`;
+                results.push(cached);
+                continue;
+            }
+            tasks.push({
+                view,
+                styles,
+            });
+        }
+        if (tasks.length > 0) {
+            await this.layouter.batchLayout({
+                batch: tasks,
+                cancelToken,
+                onSuccess: (task, result) => {
+                    results.push(this.viewSucceed(task.view, likeC4Model, result));
+                },
+                onError: (task, error) => {
+                    logger.warn(`Fail layout view ${task.view.id}`, { error });
+                },
+            });
+        }
+        if (cancelToken && cancelToken.isCancellationRequested) {
+            await interruptAndCheck(cancelToken);
+        }
+        if (results.length !== views.length) {
+            logger.warn `layouted ${results.length} of ${views.length} views in ${m0.pretty}`;
+        }
+        else if (results.length > 0) {
+            logger.debug `layouted all ${results.length} views in ${m0.pretty}`;
+        }
+        return results;
+    }
+    async layoutAllViews(projectId, cancelToken) {
+        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        return await this._layoutAllViews(likeC4Model, cancelToken);
+    }
+    async layoutView(viewId, projectId, cancelToken) {
+        const model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        const view = model.findView(viewId)?.$view;
+        projectId = model.project.id;
+        const logger = viewsLogger.getChild(projectId);
+        if (!view) {
+            logger.warn `layoutView ${viewId} not found`;
+            const project = this.services.shared.workspace.ProjectsManager.getProject(projectId);
+            const manualLayouts = await this.services.likec4.ManualLayouts.read(project);
+            const snapshot = manualLayouts?.[viewId];
+            if (snapshot) {
+                logger.debug `found manual layout for ${viewId}`;
+                return {
+                    diagram: {
+                        ...snapshot,
+                        _layout: 'manual',
+                        drifts: snapshot.drifts
+                            ? unique([
+                                ...snapshot.drifts,
+                                'not-exists',
+                            ])
+                            : ['not-exists'],
+                    },
+                    dot: '# manual layout',
+                };
+            }
+            return null;
+        }
+        let cached = this.cache.get(view);
+        if (cached) {
+            logger.debug `layout ${viewId} from cache`;
+            return await Promise.resolve().then(() => cached);
+        }
+        try {
+            const m0 = performanceMark();
+            const result = await this.layouter.layout({
+                view,
+                styles: model.$styles,
+            });
+            logger.debug(`layout {viewId} ready in ${m0.pretty}`, { viewId });
+            return this.viewSucceed(view, model, result);
+        }
+        catch (e) {
+            const errMessage = loggable(e);
+            logger.warn(errMessage);
+            this.reportViewError(view, projectId, errMessage);
+            return Promise.reject(e);
+        }
+    }
+    async diagrams(projectId, cancelToken) {
+        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        const layouted = await this._layoutAllViews(likeC4Model, cancelToken);
+        return layouted.map(({ diagram }) => {
+            const manualLayout = likeC4Model.$data.manualLayouts?.[diagram.id];
+            if (manualLayout) {
+                return applyManualLayout(diagram, manualLayout);
+            }
+            return diagram;
+        });
+    }
+    async viewsAsGraphvizOut(projectId, cancelToken) {
+        const KEY = 'All-LayoutedViews-DotWithSvg';
+        const cache = this.services.shared.workspace.Cache;
+        if (cache.has(KEY)) {
+            return await Promise.resolve(cache.get(KEY));
+        }
+        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
+        const views = values(likeC4Model.$data.views);
+        if (views.length === 0) {
+            return [];
+        }
+        const tasks = views.map(async (view) => {
+            const { dot, svg } = await this.layouter.svg({
+                view,
+                styles: likeC4Model.$styles,
+            });
+            return {
+                id: view.id,
+                dot,
+                svg,
+            };
+        });
+        const succeed = [];
+        const settledResult = await Promise.allSettled(tasks);
+        for (const result of settledResult) {
+            if (result.status === 'fulfilled') {
+                succeed.push(result.value);
+            }
+            else {
+                logWarnError(result.reason);
+            }
+        }
+        cache.set(KEY, succeed);
+        return succeed;
+    }
+    /**
+     * Open a view in the preview panel.
+     */
+    async openView(viewId, projectId) {
+        await this.services.Rpc.openView({ viewId, projectId });
+    }
+    reportViewError(view, projectId, error) {
+        const key = `${projectId}-${view.id}`;
+        if (!this.viewsWithReportedErrors.has(key)) {
+            this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${error}`);
+            this.viewsWithReportedErrors.add(key);
+        }
+    }
+    viewSucceed(view, likec4model, result) {
+        const projectId = likec4model.project.id;
+        const key = `${projectId}-${view.id}`;
+        const snapshot = likec4model.$data.manualLayouts?.[view.id];
+        if (snapshot) {
+            result.diagram = applyLayoutDriftReasons(result.diagram, snapshot);
+        }
+        this.viewsWithReportedErrors.delete(key);
+        this.cache.set(view, result);
+        return result;
+    }
+}

package/dist/views/index.d.ts

@@ -1 +1,4 @@
-export { DefaultLikeC4Views, type LikeC4Views } from './likec4-views';
+import type { LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext } from './LikeC4ManualLayouts';
+export { DefaultLikeC4Views, type LikeC4Views } from './LikeC4Views';
+export type { LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext };
+export declare const NoopLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;

package/dist/views/index.js

@@ -0,0 +1,11 @@
+export { DefaultLikeC4Views } from './LikeC4Views';
+export const NoopLikeC4ManualLayouts = {
+    manualLayouts: () => {
+        return {
+            read: () => Promise.resolve(null),
+            write: () => Promise.reject(new Error('NoopLikeC4ManualLayouts: write operation is not supported')),
+            remove: () => Promise.resolve(null),
+            clearCaches: () => { },
+        };
+    },
+};

package/dist/workspace/AstNodeDescriptionProvider.js

@@ -0,0 +1,15 @@
+import { AstUtils, DefaultAstNodeDescriptionProvider, } from 'langium';
+export class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
+    services;
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    createDescription(node, name, document) {
+        const doc = document ?? AstUtils.getDocument(node);
+        const description = super.createDescription(node, name, document);
+        doc.likec4ProjectId ??= this.services.shared.workspace.ProjectsManager.belongsTo(doc.uri);
+        description.likec4ProjectId = doc.likec4ProjectId;
+        return description;
+    }
+}

package/dist/workspace/IndexManager.js

@@ -0,0 +1,21 @@
+import { DefaultIndexManager, stream } from 'langium';
+export class IndexManager extends DefaultIndexManager {
+    services;
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    async updateContent(document, cancelToken) {
+        const projects = this.services.workspace.ProjectsManager;
+        // Ensure the document is assigned to a project
+        document.likec4ProjectId = projects.belongsTo(document.uri);
+        await super.updateContent(document, cancelToken);
+    }
+    projectElements(projectId, nodeType, uris) {
+        const projects = this.services.workspace.ProjectsManager;
+        let documentUris = stream(this.symbolIndex.keys());
+        return documentUris
+            .filter(uri => projects.belongsTo(uri) === projectId && (!uris || uris.has(uri)))
+            .flatMap(uri => this.getFileDescriptions(uri, nodeType));
+    }
+}

package/dist/workspace/LangiumDocuments.d.ts

@@ -5,7 +5,7 @@ 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;
     /**

package/dist/workspace/LangiumDocuments.js

@@ -0,0 +1,58 @@
+import { compareNaturalHierarchically } from '@likec4/core/utils';
+import { DefaultLangiumDocuments } from 'langium';
+import { groupBy, prop } from 'remeda';
+import { isLikeC4LangiumDocument } from '../ast';
+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);
+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);
+        }
+    }
+    /**
+     * Returns all user documents, excluding built-in documents.
+     */
+    get allExcludingBuiltin() {
+        const projects = this.services.workspace.ProjectsManager;
+        return super.all.filter((doc) => {
+            if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
+                return false;
+            }
+            doc.likec4ProjectId = projects.belongsTo(doc.uri);
+            return !projects.isExcluded(doc);
+        });
+    }
+    projectDocuments(projectId) {
+        return this.allExcludingBuiltin.filter(doc => doc.likec4ProjectId === projectId);
+    }
+    groupedByProject() {
+        return groupBy(this.allExcludingBuiltin.toArray(), prop('likec4ProjectId'));
+    }
+    resetProjectIds() {
+        const projects = this.services.workspace.ProjectsManager;
+        this.all.forEach(doc => {
+            if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
+                return;
+            }
+            doc.likec4ProjectId = projects.belongsTo(doc);
+        });
+    }
+}

package/dist/workspace/ProjectsManager.d.ts

@@ -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: scalar.ProjectId<string>;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns:
@@ -48,11 +48,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
      *
@@ -80,10 +84,11 @@ export declare class ProjectsManager {
     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 findProjectForDocument(documentUri: string): Pick<ProjectData, "id" | "exclude" | "config">;
     protected get mappingsToProject(): WorkspaceCache<string, Pick<ProjectData, 'id' | 'config' | 'exclude'>>;
 }
 export {};