@likec4/language-server 1.46.2 → 1.46.4

package/dist/model-change/ModelChanges.js

@@ -15,85 +15,86 @@ export class LikeC4ModelChanges {
     }
     async applyChange(changeView) {
         const lspConnection = this.services.shared.lsp.Connection;
-        let result = null;
         try {
-            await this.services.shared.workspace.WorkspaceLock.write(async () => {
-                let { viewId, projectId: _projectId, change } = changeView;
-                const project = this.services.shared.workspace.ProjectsManager.ensureProject(_projectId);
-                logger.debug `Applying model change ${change.op} to view ${viewId} in project ${project.id}`;
-                const lookup = this.locator.locateViewAst(viewId, project.id);
-                if (!lookup) {
-                    throw new Error(`View ${viewId} not found in project ${project.id}`);
+            let { viewId, projectId: _projectId, change } = changeView;
+            const project = this.services.shared.workspace.ProjectsManager.ensureProject(_projectId);
+            logger.debug `Applying model change ${change.op} to view ${viewId} in project ${project.id}`;
+            const lookup = this.locator.locateViewAst(viewId, project.id);
+            if (!lookup) {
+                throw new Error(`View ${viewId} not found in project ${project.id}`);
+            }
+            const textDocument = {
+                uri: lookup.doc.textDocument.uri,
+                version: lookup.doc.textDocument.version,
+            };
+            // TODO refactor to use separate methods for save/reset operations
+            if (change.op === 'save-view-snapshot') {
+                invariant(viewId === change.layout.id, 'View ID does not match, expected ' + viewId + ', got ' + change.layout.id);
+                // If there is an existing manual layout v1
+                if (lookup.view.manualLayout) {
+                    // We clean it up
+                    await removeManualLayoutV1(this.services, { lookup }).catch(err => {
+                        logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
+                    });
                 }
-                const textDocument = {
-                    uri: lookup.doc.textDocument.uri,
-                    version: lookup.doc.textDocument.version,
+                const location = await this.services.likec4.ManualLayouts.write(project, change.layout);
+                return {
+                    success: true,
+                    location,
                 };
-                // TODO refactor to use separate methods for save/reset operations
-                if (change.op === 'save-view-snapshot') {
-                    invariant(viewId === change.layout.id, 'View ID does not match, expected ' + viewId + ', got ' + change.layout.id);
-                    // If there is an existing manual layout v1
-                    if (lookup.view.manualLayout) {
-                        // We clean it up
-                        await removeManualLayoutV1(this.services, { lookup }).catch(err => {
-                            logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
-                        });
-                    }
-                    const location = await this.services.likec4.ManualLayouts.write(project, change.layout);
-                    result = {
-                        success: true,
-                        location,
-                    };
-                    return;
-                }
-                if (change.op === 'reset-manual-layout') {
-                    // If there is an existing manual layout v1
-                    if (lookup.view.manualLayout) {
-                        // We clean it up
-                        await removeManualLayoutV1(this.services, { lookup }).catch(err => {
-                            logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
-                        });
-                    }
-                    const location = await this.services.likec4.ManualLayouts.remove(project, viewId);
-                    result = {
-                        success: true,
-                        location,
-                    };
-                    return;
-                }
-                invariant(lspConnection, 'This change only supported in IDE (running as Extension)');
-                const { edits, modifiedRange } = this.convertToTextEdit({
-                    lookup,
-                    change,
-                });
-                if (!edits.length) {
-                    return;
-                }
-                const applyResult = await lspConnection.workspace.applyEdit({
-                    label: `LikeC4 - change view ${changeView.viewId}`,
-                    edit: {
-                        changes: {
-                            [textDocument.uri]: edits,
-                        },
-                    },
-                });
-                if (!applyResult.applied) {
-                    lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`);
-                    return;
+            }
+            if (change.op === 'reset-manual-layout') {
+                // If there is an existing manual layout v1
+                if (lookup.view.manualLayout) {
+                    // We clean it up
+                    await removeManualLayoutV1(this.services, { lookup }).catch(err => {
+                        logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
+                    });
                 }
-                result = {
+                const location = await this.services.likec4.ManualLayouts.remove(project, viewId);
+                return {
                     success: true,
-                    location: {
-                        uri: textDocument.uri,
-                        range: modifiedRange,
-                    },
+                    location,
                 };
+            }
+            invariant(lspConnection, 'This change only supported in IDE (running as Extension)');
+            const { edits, modifiedRange } = this.convertToTextEdit({
+                lookup,
+                change,
             });
+            if (!edits.length) {
+                return {
+                    success: false,
+                    error: 'No changes to apply',
+                };
+            }
+            const applyResult = await lspConnection.workspace.applyEdit({
+                label: `LikeC4 - change view ${changeView.viewId}`,
+                edit: {
+                    changes: {
+                        [textDocument.uri]: edits,
+                    },
+                },
+            });
+            if (!applyResult.applied) {
+                lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`);
+                return {
+                    success: false,
+                    error: `Failed to apply changes ${applyResult.failureReason}`,
+                };
+            }
+            return {
+                success: true,
+                location: {
+                    uri: textDocument.uri,
+                    range: modifiedRange,
+                },
+            };
         }
         catch (err) {
             const error = loggable(wrapError(err, `Failed to apply change ${changeView.change.op} ${changeView.viewId}`));
             logger.error(error);
-            result = {
+            return {
                 success: false,
                 error,
             };
@@ -101,10 +102,6 @@ export class LikeC4ModelChanges {
         finally {
             this.services.likec4.ModelBuilder.clearCache();
         }
-        return result ?? {
-            success: false,
-            error: 'Unknown error applying model change',
-        };
     }
     convertToTextEdit({ lookup, change }) {
         switch (change.op) {

package/dist/references/scope-provider.d.ts

@@ -10,7 +10,7 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     protected readonly indexManager: IndexManager;
     constructor(services: LikeC4Services);
     getScope(context: ReferenceInfo): Scope;
-    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<import("../ast").AstNodeDescriptionWithFqn, void, any>;
+    protected genUniqueDescedants(element: ast.Element | ast.DeploymentNode | undefined): Generator<import("../ast").AstNodeDescriptionWithFqn, void, any>;
     protected genScopeExtendElement({ element }: ast.ExtendElement): Generator<AstNodeDescription>;
     protected genScopeElementView({ viewOf, extends: ext }: ast.ElementView): Generator<AstNodeDescription>;
     protected getScopeForStrictFqnRef(projectId: ProjectId, container: ast.StrictFqnRef, context: ReferenceInfo): Scope;

package/dist/references/scope-provider.js

@@ -54,8 +54,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         }
     }
     // we need lazy resolving here
-    *genUniqueDescedants(of) {
-        const element = of();
+    *genUniqueDescedants(element) {
         if (!element) {
             return;
         }
@@ -83,7 +82,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             };
         }
         // we make extended element resolvable inside ExtendElementBody
-        yield* this.genUniqueDescedants(() => elementRef(element));
+        yield* this.genUniqueDescedants(elementRef(element));
     }
     *genScopeElementView({ viewOf, extends: ext }) {
         if (viewOf) {
@@ -92,7 +91,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             if (viewOf.modelElement.value.$nodeDescription) {
                 yield viewOf.modelElement.value.$nodeDescription;
             }
-            yield* this.genUniqueDescedants(() => elementRef(viewOf));
+            yield* this.genUniqueDescedants(elementRef(viewOf));
             return;
         }
         if (ext) {
@@ -115,10 +114,10 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         if (deploymentNode.value.$nodeDescription) {
             yield deploymentNode.value.$nodeDescription;
         }
-        yield* this.genUniqueDescedants(() => {
-            const target = deploymentNode.value.ref;
-            return target && ast.isDeploymentNode(target) ? target : undefined;
-        });
+        const target = deploymentNode.value.ref;
+        if (target && ast.isDeploymentNode(target)) {
+            yield* this.genUniqueDescedants(target);
+        }
     }
     streamForFqnRef(projectId, container, context) {
         const parent = container.parent;
@@ -130,25 +129,23 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             return EMPTY_STREAM;
         }
         if (ast.isImported(parentRef)) {
-            return stream(this.genUniqueDescedants(() => {
-                return parentRef.imported.ref;
-            }));
+            return stream(this.genUniqueDescedants(parentRef.imported.ref));
         }
         if (ast.isDeploymentNode(parentRef)) {
-            return stream(this.genUniqueDescedants(() => parentRef));
+            return stream(this.genUniqueDescedants(parentRef));
         }
         if (ast.isDeployedInstance(parentRef)) {
-            // if (ast.isElement(target)) {
-            return stream(this.genUniqueDescedants(() => {
-                const target = parentRef.target.modelElement.value.ref;
-                if (ast.isImported(target)) {
-                    return target.imported.ref;
-                }
-                return ast.isElement(target) ? target : undefined;
-            }));
+            const target = parentRef.target.modelElement.value.ref;
+            // dprint-ignore
+            const resolvedTarget = ast.isImported(target)
+                ? target.imported.ref
+                : ast.isElement(target)
+                    ? target
+                    : undefined;
+            return stream(this.genUniqueDescedants(resolvedTarget));
         }
         if (ast.isElement(parentRef)) {
-            return stream(this.genUniqueDescedants(() => parentRef));
+            return stream(this.genUniqueDescedants(parentRef));
         }
         return nonexhaustive(parentRef);
     }

package/dist/workspace/IndexManager.js

@@ -13,17 +13,13 @@ export class IndexManager extends DefaultIndexManager {
     }
     projectElements(projectId, nodeType, uris) {
         const projects = this.services.workspace.ProjectsManager;
-        const project = projects.getProject(projectId);
-        const includePathStrings = project.includePaths?.map(uri => {
-            const path = uri.toString();
-            return path.endsWith('/') ? path : path + '/';
-        }) ?? [];
         let documentUris = stream(this.symbolIndex.keys());
         return documentUris
             .filter(uri => {
-            const belongsToProject = projects.belongsTo(uri) === projectId;
-            const inIncludePath = includePathStrings.some(includePath => uri.startsWith(includePath));
-            return (belongsToProject || inIncludePath) && (!uris || uris.has(uri));
+            if (uris && !uris.has(uri)) {
+                return false;
+            }
+            return projects.isIncluded(projectId, uri);
         })
             .flatMap(uri => this.getFileDescriptions(uri, nodeType));
     }

package/dist/workspace/LangiumDocuments.d.ts

@@ -5,15 +5,21 @@ import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4SharedServices } from '../module';
 export declare class LangiumDocuments extends DefaultLangiumDocuments {
     protected services: LikeC4SharedServices;
-    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.
+     * Returns all documents, excluding built-in documents and documents excluded by ProjectsManager.
      */
     get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
+    /**
+     * Returns all documents for a project, including both project documents and documents included by the project.
+     */
     projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
     groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+    /**
+     * Reset the project IDs of all documents.
+     */
+    resetProjectIds(): void;
 }

package/dist/workspace/LangiumDocuments.js

@@ -1,6 +1,6 @@
 import { compareNaturalHierarchically } from '@likec4/core/utils';
 import { DefaultLangiumDocuments, stream } from 'langium';
-import { groupBy, prop } from 'remeda';
+import { hasAtLeast } from 'remeda';
 import { isLikeC4LangiumDocument } from '../ast';
 import { LikeC4LanguageMetaData } from '../generated/module';
 import { isLikeC4Builtin } from '../likec4lib';
@@ -14,7 +14,6 @@ const exclude = (doc) => {
 };
 export class LangiumDocuments extends DefaultLangiumDocuments {
     services;
-    compare = compareNaturalHierarchically('/', true);
     constructor(services) {
         super(services);
         this.services = services;
@@ -34,7 +33,7 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
     getDocument(uri) {
         const doc = super.getDocument(uri);
         if (doc && !exclude(doc)) {
-            doc.likec4ProjectId ??= this.services.workspace.ProjectsManager.belongsTo(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`);
@@ -46,7 +45,7 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
             .filter((doc) => {
             if (doc.textDocument.languageId === LikeC4LanguageMetaData.languageId) {
                 if (!isLikeC4Builtin(doc.uri)) {
-                    doc.likec4ProjectId ??= this.services.workspace.ProjectsManager.belongsTo(doc);
+                    doc.likec4ProjectId = this.services.workspace.ProjectsManager.belongsTo(doc);
                 }
                 return true;
             }
@@ -54,37 +53,46 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
         });
     }
     /**
-     * Returns all user documents, excluding built-in documents.
+     * Returns all documents, excluding built-in documents and documents excluded by ProjectsManager.
      */
     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);
+        return this.all.filter((doc) => {
+            return !(isLikeC4Builtin(doc.uri) || projects.isExcluded(doc));
         });
     }
+    /**
+     * Returns all documents for a project, including both project documents and documents included by the project.
+     */
     projectDocuments(projectId) {
         const projects = this.services.workspace.ProjectsManager;
-        const project = projects.getProject(projectId);
-        const projectFolder = project.folderUri.toString() + (project.folderUri.path.endsWith('/') ? '' : '/');
-        const includePathStrings = project.includePaths?.map(uri => {
-            const path = uri.toString();
-            return path.endsWith('/') ? path : path + '/';
-        }) ?? [];
-        return this.allExcludingBuiltin.filter(doc => {
-            const docUri = doc.uri.toString();
-            // Always include documents from the project's own folder
-            if (docUri.startsWith(projectFolder)) {
-                return true;
+        return this.all.filter(doc => {
+            if (isLikeC4Builtin(doc.uri)) {
+                return false;
             }
-            // Check for addtional documents when the config has the `include:paths` property set.
-            if (includePathStrings.length > 0) {
-                return includePathStrings.some(includePath => docUri.startsWith(includePath));
-            }
-            return false;
+            return projects.isIncluded(projectId, doc.uri);
         });
     }
     groupedByProject() {
-        return groupBy(this.allExcludingBuiltin.toArray(), prop('likec4ProjectId'));
+        return this.services.workspace.ProjectsManager
+            .all
+            .reduce((acc, projectId) => {
+            const docs = this.projectDocuments(projectId).toArray();
+            if (hasAtLeast(docs, 1)) {
+                acc[projectId] = docs;
+            }
+            return acc;
+        }, {});
+    }
+    /**
+     * Reset the project IDs of all documents.
+     */
+    resetProjectIds() {
+        super.all.forEach(doc => {
+            if (exclude(doc)) {
+                return;
+            }
+            delete doc.likec4ProjectId;
+        });
     }
 }

package/dist/workspace/ProjectsManager.d.ts

@@ -1,7 +1,8 @@
 import { type IncludeConfig, type LikeC4ProjectConfig, type LikeC4ProjectConfigInput } from '@likec4/config';
-import type { NonEmptyReadonlyArray } from '@likec4/core';
+import type { NonEmptyArray, NonEmptyReadonlyArray } from '@likec4/core';
 import type { ProjectId, scalar } from '@likec4/core/types';
 import { type Cancellation, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import picomatch from 'picomatch';
 import type { Tagged } from 'type-fest';
 import type { LikeC4SharedServices } from '../module';
 /**
@@ -15,12 +16,12 @@ interface ProjectData {
     config: LikeC4ProjectConfig;
     folder: ProjectFolder;
     folderUri: URI;
-    exclude?: (path: string) => boolean;
+    exclude?: picomatch.Matcher;
     /**
      * Resolved include paths with both URI and folder string representations.
      * These are additional directories that are part of this project.
      */
-    includePaths?: Array<{
+    includePaths?: NonEmptyArray<{
         uri: URI;
         folder: ProjectFolder;
     }>;
@@ -36,7 +37,7 @@ export interface Project {
     /**
      * Resolved include paths as URIs (if configured).
      */
-    includePaths?: URI[];
+    includePaths?: NonEmptyReadonlyArray<URI>;
 }
 export declare class ProjectsManager {
     #private;
@@ -74,6 +75,12 @@ export declare class ProjectsManager {
      * Checks if the specified document should be excluded from processing.
      */
     isExcluded(document: LangiumDocument | URI | string): boolean;
+    /**
+     * 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: ProjectId, document: LangiumDocument | URI | string): boolean;
     /**
      * Checks if it is a config file and it is not excluded by default exclude pattern
      *
@@ -83,7 +90,7 @@ export declare class ProjectsManager {
     /**
      * Registers likec4 project by config file.
      */
-    registerConfigFile(configFile: URI): Promise<ProjectData>;
+    registerConfigFile(configFile: URI, cancelToken?: Cancellation.CancellationToken): 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.
@@ -91,14 +98,14 @@ export declare class ProjectsManager {
     registerProject(opts: {
         config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
         folderUri: URI | string;
-    }): Promise<ProjectData>;
+    }, cancelToken?: Cancellation.CancellationToken): Promise<ProjectData>;
     /**
      * Determines which project the given document belongs to.
      * If the document does not belong to any project, returns the default project ID.
      */
     belongsTo(document: LangiumDocument | URI | string): scalar.ProjectId;
-    reloadProjects(): Promise<void>;
-    protected _reloadProjects(): Promise<void>;
+    reloadProjects(cancelToken?: Cancellation.CancellationToken): Promise<void>;
+    protected _reloadProjects(cancelToken?: Cancellation.CancellationToken): Promise<void>;
     protected uniqueProjectId(name: string): scalar.ProjectId;
     protected reset(): void;
     rebuidProject(projectId: ProjectId, cancelToken?: Cancellation.CancellationToken): Promise<void>;