@likec4/language-server 1.47.0 → 1.48.0

package/dist/workspace/ProjectsManager.js

@@ -1,610 +0,0 @@
-var _a;
-import { isLikeC4Config, normalizeIncludeConfig, validateProjectConfig, } from '@likec4/config';
-import { BiMap, compareNaturalHierarchically, DefaultMap, invariant, memoizeProp, nonNullable, } from '@likec4/core/utils';
-import { loggable, wrapError } from '@likec4/log';
-import { deepEqual } from 'fast-equals';
-import { isOperationCancelled, OperationCancelled, URI, WorkspaceCache, } from 'langium';
-import picomatch from 'picomatch';
-import { filter, hasAtLeast, isNullish, map, pipe, prop, sort } from 'remeda';
-import { cleanDoubleSlashes, isRelative, joinRelativeURL, joinURL, parseFilename, withoutProtocol, withoutTrailingSlash, 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();
-    }
-}
-/**
- * Compare function to ensure consistent order
- */
-const compare = compareNaturalHierarchically('/', true);
-const compareUri = (a, b) => compare(withoutTrailingSlash(a.path), withoutTrailingSlash(b.path));
-/**
- * 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);
-}
-const DefaultProject = {
-    id: 'default',
-    config: {
-        name: 'default',
-        exclude: ['**/node_modules/**'],
-    },
-    exclude: picomatch('**/node_modules/**', { dot: true }),
-    includeConfig: { paths: [], maxDepth: 3, fileThreshold: 30 },
-};
-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 = [];
-    /**
-     * This is a cached lookup for performance.
-     */
-    #lookupById = new DefaultMap((id) => {
-        if (id === _a.DefaultProjectId) {
-            const folder = ProjectFolder(this.getWorkspaceFolder());
-            return {
-                id,
-                config: DefaultProject.config,
-                folder,
-                folderUri: URI.parse(folder),
-                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;
-        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 ?? _a.DefaultProjectId;
-    }
-    set defaultProjectId(id) {
-        if (id === this.#defaultProjectId) {
-            return;
-        }
-        this.#defaultProject = undefined;
-        if (!id || id === _a.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 ?? _a.DefaultProjectId;
-            this.#defaultProject = this.#lookupById.get(id);
-        }
-        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));
-        const project = this.#lookupById.get(id);
-        return {
-            id,
-            folderUri: project.folderUri,
-            config: project.config,
-            ...(project.includePaths && { includePaths: map(project.includePaths, prop('uri')) }),
-        };
-    }
-    /**
-     * Returns all projects that include the specified folder, or inside the folder.
-     */
-    findAllProjectsByFolder(folder) {
-        const projectFolder = ProjectFolder(folder);
-        const isInsideOrIncludes = (p) => p.folder.startsWith(projectFolder) || projectFolder.startsWith(p.folder);
-        return this.#projects.filter(isInsideOrIncludes);
-    }
-    /**
-     * 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 === _a.DefaultProjectId) {
-            return this.defaultProjectId ?? _a.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);
-            if (!project.exclude) {
-                return false;
-            }
-            const input = withoutProtocol(docUriAsString);
-            return project.exclude(input);
-        }
-        let isExcluded = this.#excludedDocuments.get(document);
-        if (isExcluded === undefined) {
-            isExcluded = this.isExcluded(document.uri);
-            this.#excludedDocuments.set(document, isExcluded);
-        }
-        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
-     *
-     * @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, cancelToken) {
-        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 }, cancelToken);
-        }
-        catch (error) {
-            if (!isOperationCancelled(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`);
-            }
-            return Promise.reject(error);
-        }
-    }
-    /**
-     * 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, cancelToken) {
-        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);
-            const includeConfig = normalizeIncludeConfig(config.include);
-            project = {
-                id,
-                config,
-                folder,
-                folderUri: URI.parse(folder),
-                includeConfig,
-            };
-            // 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], sort((a, b) => compareUri(a.folderUri, b.folderUri)));
-            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;
-            const includeConfig = normalizeIncludeConfig(config.include);
-            project.includeConfig = includeConfig;
-        }
-        if (isNullish(config.exclude)) {
-            project.exclude = DefaultProject.exclude;
-        }
-        else if (hasAtLeast(config.exclude, 1)) {
-            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 = map(project.includeConfig.paths, includePath => {
-                const resolvedPath = joinRelativeURL(project.folderUri.path, includePath);
-                const uri = project.folderUri.with({ path: resolvedPath });
-                return {
-                    uri,
-                    folder: ProjectFolder(uri),
-                };
-            });
-            logger.debug `project ${project.id} include paths: ${project.includePaths.map(p => p.uri.fsPath).join(', ')}`;
-            // Check for overlapping include paths with other projects
-            for (const includePath of project.includePaths) {
-                // Check if this include path overlaps with another project's folder
-                for (const otherProject of this.#projects) {
-                    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 });
-                    }
-                    // Check if this include path overlaps with another project's include paths
-                    if (otherProject.includePaths) {
-                        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,
-                                    includePath: includePath.folder,
-                                    otherProjectId: otherProject.id,
-                                    otherIncludePath: otherIncludePath.folder,
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            delete project.includePaths;
-        }
-        // Reset cached default project
-        this.#defaultProject = undefined;
-        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, cancelToken).catch(error => {
-                if (isOperationCancelled(error)) {
-                    return Promise.reject(error);
-                }
-                logger.warn('Failed to rebuild project {projectId} after config change', {
-                    projectId: project.id,
-                    error,
-                });
-                // ignore error, we logged it
-                return Promise.resolve();
-            });
-        }
-        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(cancelToken) {
-        if (this.#activeReload) {
-            logger.debug `reload projects is already in progress, waiting`;
-            return await this.#activeReload.catch(() => {
-                // ignore errors
-            });
-        }
-        logger.debug `schedule reload projects`;
-        this.#activeReload = Promise.resolve()
-            .then(() => this._reloadProjects(cancelToken))
-            .catch(error => {
-            if (!isOperationCancelled(error)) {
-                logger.warn('Failed to reload projects', { error });
-            }
-            return Promise.reject(error);
-        })
-            .finally(() => {
-            this.#activeReload = null;
-        });
-        return await this.#activeReload;
-    }
-    async _reloadProjects(cancelToken) {
-        const folders = this.services.workspace.WorkspaceManager.workspaceFolders;
-        if (!folders) {
-            logger.warn('No workspace folders found');
-            return;
-        }
-        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');
-        }
-        // Sort config files hierarchically, ensuring consistent order
-        configFiles.sort(compareUri);
-        this.#projects = [];
-        this.#projectIdToFolder.clear();
-        this.#lookupById.clear();
-        for (const uri of configFiles) {
-            if (cancelToken?.isCancellationRequested) {
-                break;
-            }
-            await this.registerConfigFile(uri, cancelToken).catch(error => {
-                if (!isOperationCancelled(error)) {
-                    logger.warn(loggable(error));
-                }
-            });
-        }
-        this.reset();
-        if (cancelToken?.isCancellationRequested) {
-            throw OperationCancelled;
-        }
-        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() {
-        logger.debug('reset');
-        this.#defaultProject = undefined;
-        if (this.#defaultProjectId && !this.#projectIdToFolder.has(this.#defaultProjectId)) {
-            this.#defaultProjectId = undefined;
-        }
-        this.services.workspace.LangiumDocuments.resetProjectIds();
-        this.documentBelongsTo.clear();
-        this.mappingsToProject.clear();
-        this.#lookupById.clear();
-        this.#excludedDocuments = new WeakMap();
-    }
-    async rebuidProject(projectId, cancelToken) {
-        // reset default project cache
-        this.#defaultProject = undefined;
-        const project = this.#projects.find(p => p.id === projectId) ?? this.default;
-        if (project.id !== projectId) {
-            logger.warn `Project ${projectId} not found, rebuilding default project ${project.id}`;
-        }
-        const log = logger.getChild(project.id);
-        const folder = project.folder;
-        const includePaths = project.includePaths;
-        const allDocs = this.services.workspace.LangiumDocuments
-            .allKnownDocuments
-            .filter(doc => !isLikeC4Builtin(doc.uri))
-            .toArray();
-        // If no documents are found, return early
-        if (allDocs.length === 0) {
-            return;
-        }
-        const docs = pipe(allDocs, filter(doc => {
-            if (project.exclude?.(doc.uri.path)) {
-                return false;
-            }
-            const docUriStr = normalizeUri(doc.uri);
-            if (docUriStr.startsWith(folder)) {
-                return true;
-            }
-            if (includePaths && includePaths.some(isParentFolderFor(docUriStr))) {
-                return true;
-            }
-            const docdir = withTrailingSlash(joinRelativeURL(docUriStr, '..'));
-            return docdir.startsWith(folder) || folder.startsWith(docdir);
-        }), map(d => d.uri));
-        if (docs.length === 0) {
-            log.debug('no documents in project, skipping rebuild');
-            return;
-        }
-        log.info('rebuild project documents: {docs}', {
-            docs: docs.length,
-        });
-        this.reset();
-        await this.services.workspace.DocumentBuilder
-            .update(docs, [], cancelToken)
-            .catch(error => {
-            log.warn('Failed to rebuild project', {
-                error,
-            });
-        });
-    }
-    findProjectForDocument(documentUri) {
-        return this.mappingsToProject.get(documentUri, () => {
-            const hasThisDoc = isParentFolderFor(documentUri);
-            const project = this.#projects.find(hasThisDoc);
-            if (project) {
-                return project;
-            }
-            const projectIncludingThisDoc = this.#projects.find(({ includePaths }) => {
-                return !!includePaths && includePaths.some(hasThisDoc);
-            });
-            // If the document is not part of any project, assign it to the global project ID
-            return projectIncludingThisDoc ?? 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));
-    }
-    /**
-     * Returns all include paths from all projects.
-     * Used by WorkspaceManager to scan additional directories for C4 files.
-     */
-    getAllIncludePaths() {
-        const result = [];
-        for (const project of this.#projects) {
-            if (project.includePaths) {
-                for (const includePath of project.includePaths) {
-                    result.push({
-                        projectId: project.id,
-                        includePath: includePath.uri,
-                        includeConfig: project.includeConfig,
-                    });
-                }
-            }
-        }
-        return result;
-    }
-    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
-        }
-    }
-}
-_a = ProjectsManager;

package/dist/workspace/WorkspaceManager.d.ts

@@ -1,31 +0,0 @@
-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';
-import type { FileSystemProvider } from '../filesystem';
-import type { LikeC4SharedServices } from '../module';
-export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-    private services;
-    protected readonly documentFactory: LangiumDocumentFactory;
-    protected readonly fileSystemProvider: FileSystemProvider;
-    initialBuildOptions: BuildOptions;
-    constructor(services: LikeC4SharedServices);
-    /**
-     * First load all project config files, then load all documents in the workspace.
-     */
-    protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
-    /**
-     * Load all additional documents that shall be visible in the context of the given workspace
-     * folders and add them to the collector. This can be used to include built-in libraries of
-     * your language, which can be either loaded from provided files or constructed in memory.
-     */
-    protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
-    /**
-     * Determine whether the given folder entry shall be included while indexing the workspace.
-     */
-    protected includeEntry(_workspaceFolder: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
-    workspace(): WorkspaceFolder | null;
-    rebuildAll(cancelToken?: Cancellation.CancellationToken): Promise<void>;
-    get workspaceUri(): URI;
-    get workspaceURL(): URL;
-}