@likec4/language-server 1.44.0 → 1.45.0

package/dist/views/LikeC4Views.d.ts

@@ -1,4 +1,4 @@
-import type { ComputedView, DiagramView, LayoutedView, ProjectId, ViewId } from '@likec4/core';
+import type { ComputedView, DiagramView, LayoutedView, LayoutType, ProjectId, ViewId } from '@likec4/core';
 import { type QueueGraphvizLayoter, GraphvizLayouter } from '@likec4/layouts';
 import type { CancellationToken } from 'vscode-languageserver';
 import type { LikeC4Services } from '../module';
@@ -11,6 +11,18 @@ type GraphvizSvgOut = {
     readonly dot: string;
     readonly svg: string;
 };
+type LayoutViewParams = {
+    viewId: ViewId;
+    /**
+     * Type of layout to apply
+     * - 'manual' - applies manual layout if any
+     * - 'auto' - returns latest version with drifts from manual layout if any
+     * - undefined - returns latest layout as is
+     */
+    layoutType?: LayoutType | undefined;
+    projectId?: ProjectId | undefined;
+    cancelToken?: CancellationToken | undefined;
+};
 export interface LikeC4Views {
     readonly layouter: GraphvizLayouter;
     /**
@@ -18,14 +30,18 @@ export interface LikeC4Views {
      */
     computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
     /**
-     * Returns all layouted views (without manual layout)
+     * Layouts all views (ignoring any manual snapshots)
      */
     layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut[]>;
     /**
-     * Layouts a view (from sources, i.e. without manual layout)
+     * Layouts a view.
+     * If layoutType is 'manual' - applies manual layout if any.
+     * If layoutType is 'auto' - returns latest version with drifts from manual layout if any
+     * If not specified - returns latest layout as is
+     *
      * 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>;
+    layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
     /**
      * Returns diagrams.
      * If diagram has manual layout, it will be used.
@@ -55,7 +71,7 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
     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>;
+    layoutView({ viewId, layoutType, projectId, cancelToken, }: LayoutViewParams): Promise<GraphvizOut | null>;
     diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<LayoutedView>>;
     viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
     /**
@@ -63,6 +79,11 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
      */
     openView(viewId: ViewId, projectId: ProjectId): Promise<void>;
     private reportViewError;
+    /**
+     * Applies manual layout or calculates drifts from snapshot
+     * if layoutType is specified
+     */
+    private withLayoutType;
     private viewSucceed;
 }
 export {};

package/dist/views/LikeC4Views.js

@@ -1,8 +1,8 @@
-import { applyLayoutDriftReasons, applyManualLayout } from '@likec4/core/model';
+import { _layout, applyManualLayout, calcDriftsFromSnapshot, invariant } from '@likec4/core';
 import { GraphvizLayouter } from '@likec4/layouts';
 import { loggable } from '@likec4/log';
 import { interruptAndCheck } from 'langium';
-import { unique, values } from 'remeda';
+import { isTruthy, unique, values } from 'remeda';
 import { logger as rootLogger, logWarnError } from '../logger';
 import { performanceMark } from '../utils';
 const viewsLogger = rootLogger.getChild('views');
@@ -78,47 +78,48 @@ export class DefaultLikeC4Views {
         const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
         return await this._layoutAllViews(likeC4Model, cancelToken);
     }
-    async layoutView(viewId, projectId, cancelToken) {
+    async layoutView({ viewId, layoutType, 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];
+            const snapshot = model.findManualLayout(viewId);
             if (snapshot) {
                 logger.debug `found manual layout for ${viewId}`;
+                let diagram = { ...snapshot };
+                diagram.drifts = [
+                    'not-exists',
+                ];
+                diagram._layout = 'manual';
                 return {
-                    diagram: {
-                        ...snapshot,
-                        _layout: 'manual',
-                        drifts: snapshot.drifts
-                            ? unique([
-                                ...snapshot.drifts,
-                                'not-exists',
-                            ])
-                            : ['not-exists'],
-                    },
+                    diagram: diagram,
                     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({
+            const out = this.cache.get(view) ?? await this.layouter.layout({
                 view,
                 styles: model.$styles,
             });
-            logger.debug(`layout {viewId} ready in ${m0.pretty}`, { viewId });
-            return this.viewSucceed(view, model, result);
+            if (this.cache.has(view)) {
+                logger.debug `layout ${viewId} from cache`;
+            }
+            else {
+                this.viewSucceed(view, model, out);
+                logger.debug(`layout {viewId} in ${m0.pretty}`, { viewId });
+            }
+            if (isTruthy(layoutType)) {
+                return {
+                    dot: out.dot,
+                    diagram: this.withLayoutType(out.diagram, model, layoutType),
+                };
+            }
+            return out;
         }
         catch (e) {
             const errMessage = loggable(e);
@@ -131,11 +132,8 @@ export class DefaultLikeC4Views {
         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;
+            // Apply manual layout if any
+            return this.withLayoutType(diagram, likeC4Model, 'manual');
         });
     }
     async viewsAsGraphvizOut(projectId, cancelToken) {
@@ -181,18 +179,36 @@ export class DefaultLikeC4Views {
     }
     reportViewError(view, projectId, error) {
         const key = `${projectId}-${view.id}`;
+        this.cache.delete(view);
         if (!this.viewsWithReportedErrors.has(key)) {
             this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${error}`);
             this.viewsWithReportedErrors.add(key);
         }
     }
+    /**
+     * Applies manual layout or calculates drifts from snapshot
+     * if layoutType is specified
+     */
+    withLayoutType(layouted, likec4model, layoutType) {
+        if (!layoutType) {
+            return layouted;
+        }
+        const snapshot = likec4model.findManualLayout(layouted.id);
+        if (!snapshot) {
+            return layouted;
+        }
+        if (layoutType === 'manual') {
+            if (layouted[_layout] === 'manual') {
+                viewsLogger.error(`View ${layouted.id} already has manual layout, this should not happen`);
+                return layouted;
+            }
+            return applyManualLayout(layouted, snapshot);
+        }
+        return calcDriftsFromSnapshot(layouted, snapshot);
+    }
     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/workspace/AstNodeDescriptionProvider.js

@@ -1,4 +1,5 @@
 import { AstUtils, DefaultAstNodeDescriptionProvider, } from 'langium';
+import { isLikeC4Builtin } from '../likec4lib';
 export class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
     services;
     constructor(services) {
@@ -6,10 +7,12 @@ export class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvide
         this.services = services;
     }
     createDescription(node, name, document) {
-        const doc = document ?? AstUtils.getDocument(node);
+        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;
+        if (!isLikeC4Builtin(document.uri)) {
+            document.likec4ProjectId ??= this.services.shared.workspace.ProjectsManager.belongsTo(document);
+            description.likec4ProjectId = document.likec4ProjectId;
+        }
         return description;
     }
 }

package/dist/workspace/IndexManager.js

@@ -8,7 +8,7 @@ export class IndexManager extends DefaultIndexManager {
     async updateContent(document, cancelToken) {
         const projects = this.services.workspace.ProjectsManager;
         // Ensure the document is assigned to a project
-        document.likec4ProjectId = projects.belongsTo(document.uri);
+        document.likec4ProjectId = projects.belongsTo(document);
         await super.updateContent(document, cancelToken);
     }
     projectElements(projectId, nodeType, uris) {

package/dist/workspace/LangiumDocuments.d.ts

@@ -1,5 +1,5 @@
 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';
@@ -8,11 +8,12 @@ export declare class LangiumDocuments extends DefaultLangiumDocuments {
     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

@@ -1,13 +1,17 @@
 import { compareNaturalHierarchically } from '@likec4/core/utils';
-import { DefaultLangiumDocuments } from 'langium';
+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);
@@ -27,17 +31,36 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
             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) => {
-            if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
-                return false;
-            }
-            doc.likec4ProjectId = projects.belongsTo(doc.uri);
-            return !projects.isExcluded(doc);
+            // Exclude built-in and non-LikeC4 documents, and also documents excluded by ProjectsManager
+            return !exclude(doc) && !projects.isExcluded(doc);
         });
     }
     projectDocuments(projectId) {
@@ -46,13 +69,4 @@ export class LangiumDocuments extends DefaultLangiumDocuments {
     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

@@ -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<string>;
+    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;
     /**
@@ -64,31 +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): Pick<ProjectData, "id" | "exclude" | "config">;
-    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 {};