@likec4/language-server 1.44.0 → 1.45.0

package/dist/LikeC4LanguageServices.d.ts

@@ -37,6 +37,7 @@ export interface LikeC4LanguageServices {
     };
     /**
      * Returns diagrams (i.e. views with layout computed) for the specified project
+     * if diagram has manual layout, it will be used
      * If no project is specified, returns diagrams for default project
      */
     diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<DiagramView[]>;
@@ -48,14 +49,6 @@ export interface LikeC4LanguageServices {
         range: Range;
         sourceFsPath: string;
     }>;
-    /**
-     * Notifies the language server about changes in the workspace
-     * @deprecated use watcher instead
-     */
-    notifyUpdate(update: {
-        changed?: string;
-        removed?: string;
-    }): Promise<boolean>;
     /**
      * Returns the location of the specified element, relation, view or deployment element
      */
@@ -108,13 +101,6 @@ export declare class DefaultLikeC4LanguageServices implements LikeC4LanguageServ
         range: Range;
         sourceFsPath: string;
     }>;
-    /**
-     * TODO Replace with watcher
-     */
-    notifyUpdate({ changed, removed }: {
-        changed?: string;
-        removed?: string;
-    }): Promise<boolean>;
     locate(params: Locate.Params): Locate.Res;
     dispose(): Promise<void>;
 }

package/dist/LikeC4LanguageServices.js

@@ -4,8 +4,7 @@ import { loggable } from '@likec4/log';
 import { URI } from 'langium';
 import { entries, hasAtLeast, indexBy, map, pipe, prop } from 'remeda';
 import { DiagnosticSeverity } from 'vscode-languageserver-types';
-import { isLikeC4LangiumDocument } from './ast';
-import { logger as mainLogger, logWarnError } from './logger';
+import { logger as mainLogger } from './logger';
 import { ProjectsManager } from './workspace';
 const logger = mainLogger.getChild('LanguageServices');
 /**
@@ -99,7 +98,7 @@ export class DefaultLikeC4LanguageServices {
         const projectId = this.projectsManager.ensureProjectId(project);
         const model = await this.builder.computeModel(projectId, cancelToken);
         if (!model) {
-            throw new Error('Failed to parse model');
+            throw new Error('Failed to compute model, empty project?');
         }
         const layouted = await this.views.layoutAllViews(projectId, cancelToken);
         return LikeC4Model.create({
@@ -121,35 +120,6 @@ export class DefaultLikeC4LanguageServices {
             }));
         });
     }
-    /**
-     * TODO Replace with watcher
-     */
-    async notifyUpdate({ changed, removed }) {
-        if (!changed && !removed) {
-            return false;
-        }
-        const _changed = changed ? URI.file(changed) : undefined;
-        const _removed = removed ? URI.file(removed) : undefined;
-        const pm = this.services.shared.workspace.ProjectsManager;
-        if ((_changed && pm.isConfigFile(_changed)) || (_removed && pm.isConfigFile(_removed))) {
-            await pm.reloadProjects();
-            return true;
-        }
-        const mutex = this.services.shared.workspace.WorkspaceLock;
-        try {
-            let completed = false;
-            await mutex.write(async (token) => {
-                await this.services.shared.workspace.DocumentBuilder.update(_changed ? [_changed] : [], _removed ? [_removed] : [], token);
-                // we come here if only the update was successful, did not throw and not cancelled
-                completed = !token.isCancellationRequested;
-            });
-            return completed;
-        }
-        catch (e) {
-            logger.error(loggable(e));
-            return false;
-        }
-    }
     locate(params) {
         switch (true) {
             case 'element' in params:

package/dist/Rpc.js

@@ -1,11 +1,10 @@
 import { filter, flatMap, funnel, indexBy, keys, map, mapValues, pipe, sort } from 'remeda';
 import { logger as rootLogger } from './logger';
-import { serializableLikeC4ProjectConfig } from '@likec4/config';
 import { invariant, nonexhaustive, } from '@likec4/core';
 import { LikeC4Model } from '@likec4/core/model';
 import { Disposable, interruptAndCheck, URI, UriUtils } from 'langium';
 import { DiagnosticSeverity } from 'vscode-languageserver-protocol';
-import { BuildDocuments, ChangeView, DidChangeModelNotification, DidRequestOpenViewNotification, FetchComputedModel, FetchLayoutedModel, FetchProjects, FetchTelemetryMetrics, FetchViewsFromAllProjects, GetDocumentTags, LayoutView, Locate, RegisterProject, ReloadProjects, ValidateLayout, } from './protocol';
+import { BuildDocuments, ChangeView, DidChangeModelNotification, DidChangeSnapshotNotification, DidRequestOpenViewNotification, FetchComputedModel, FetchLayoutedModel, FetchProjects, FetchTelemetryMetrics, FetchViewsFromAllProjects, GetDocumentTags, LayoutView, Locate, RegisterProject, ReloadProjects, ValidateLayout, } from './protocol';
 import { ADisposable } from './utils';
 const logger = rootLogger.getChild('rpc');
 export class Rpc extends ADisposable {
@@ -17,28 +16,28 @@ export class Rpc extends ADisposable {
     init() {
         const connection = this.services.shared.lsp.Connection;
         if (!connection) {
-            logger.info(`[ServerRpc] no connection, not initializing`);
+            logger.info(`no connection, skip init ServerRpc`);
             return;
         }
-        logger.info(`[ServerRpc] init`);
+        logger.info(`init ServerRpc`);
         const likec4Services = this.services.likec4;
         const projects = this.services.shared.workspace.ProjectsManager;
         const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
         const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
-        const notifyModelParsed = funnel(() => {
-            logger.debug `sendNotification ${'onDidChangeModel'}`;
+        const notifyModelParsed = funnel((batch) => {
+            logger.debug `send onDidChangeModel ${batch > 1 ? '(' + batch + ' batched)' : ''}`;
             connection.sendNotification(DidChangeModelNotification.type, '').catch(error => {
                 logger.warn(`[ServerRpc] error sending onDidChangeModel:`, { error });
                 return;
             });
         }, {
+            reducer: (accumulator, req) => (accumulator ?? 0) + req,
             triggerAt: 'end',
-            minQuietPeriodMs: 150,
-            maxBurstDurationMs: 500,
-            minGapMs: 300,
+            minQuietPeriodMs: 200,
+            maxBurstDurationMs: 400,
         });
         let isFirstBuild = true;
-        this.onDispose(likec4Services.ModelBuilder.onModelParsed(() => notifyModelParsed.call()), connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
+        this.onDispose(likec4Services.ModelBuilder.onModelParsed(() => notifyModelParsed.call(1)), connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
             logger.debug `received request ${'fetchComputedModel'} for project ${projectId}`;
             if (cleanCaches) {
                 const docs = projectId
@@ -52,6 +51,10 @@ export class Rpc extends ADisposable {
                 return { model: likec4model.$model };
             }
             return { model: null };
+        }), connection.onNotification(DidChangeSnapshotNotification.type, async ({ snapshotUri }) => {
+            logger.debug `received notification ${'onDidChangeSnapshot'} for snapshot ${snapshotUri}`;
+            const uri = URI.parse(snapshotUri);
+            await projects.rebuidProject(projects.belongsTo(uri.path));
         }), connection.onRequest(FetchLayoutedModel.req, async ({ projectId }, cancelToken) => {
             logger.debug `received request ${'fetchLayoutedModel'} for project ${projectId}`;
             const model = await likec4Services.LanguageServices.layoutedModel(projectId);
@@ -66,24 +69,33 @@ export class Rpc extends ADisposable {
                     views: indexBy(diagrams, d => d.id),
                 },
             };
-        }), connection.onRequest(LayoutView.req, async ({ viewId, projectId }, cancelToken) => {
-            logger.debug `received request ${'layoutView'} for ${viewId} from project ${projectId}`;
-            const result = await likec4Services.Views.layoutView(viewId, projectId, cancelToken);
+        }), connection.onRequest(LayoutView.req, async ({ viewId, projectId, layoutType, }, cancelToken) => {
+            logger
+                .debug `received request ${'layoutView'} for ${viewId} from project ${projectId} (layout type: ${layoutType ?? 'not set'})`;
+            const result = await likec4Services.Views.layoutView({
+                viewId,
+                projectId: projectId,
+                layoutType,
+                cancelToken,
+            });
             return { result };
-        }), connection.onRequest(ValidateLayout.Req, async ({ projectId }, cancelToken) => {
+        }), connection.onRequest(ValidateLayout.req, async ({ projectId }, cancelToken) => {
             logger.debug `received request ${'validateLayout'} for project ${projectId}`;
             const layouts = await likec4Services.Views.layoutAllViews(projectId, cancelToken);
             const result = reportLayoutDrift(layouts.map(l => l.diagram));
             return { result };
-        }), connection.onRequest(FetchProjects.req, async (_cancelToken) => {
+        }), connection.onRequest(FetchProjects.req, async () => {
             logger.debug `received request ${'FetchProjects'}`;
             const docsByProject = LangiumDocuments.groupedByProject();
             return {
                 projects: mapValues(docsByProject, (docs, projectId) => {
-                    const { folderUri, config, } = projects.getProject(projectId);
+                    const { folderUri, config: { name, title, }, } = projects.getProject(projectId);
                     return {
                         folder: folderUri.toString(),
-                        config: serializableLikeC4ProjectConfig(config),
+                        config: {
+                            name,
+                            title,
+                        },
                         docs: map(docs, d => d.uri.toString()),
                     };
                 }),
@@ -120,7 +132,7 @@ export class Rpc extends ADisposable {
             return {
                 views: pipe(results, filter(r => r.status === 'fulfilled'), flatMap(r => r.value)),
             };
-        }), connection.onRequest(BuildDocuments.Req, async ({ docs }, cancelToken) => {
+        }), connection.onRequest(BuildDocuments.req, async ({ docs }, cancelToken) => {
             const changed = docs.map(d => URI.parse(d));
             const notChanged = (uri) => changed.every(c => !UriUtils.equals(c, uri));
             const deleted = LangiumDocuments.allExcludingBuiltin
@@ -149,7 +161,7 @@ export class Rpc extends ADisposable {
             isFirstBuild = false;
             await interruptAndCheck(cancelToken);
             await DocumentBuilder.update(changed, deleted, cancelToken);
-        }), connection.onRequest(Locate.Req, params => {
+        }), connection.onRequest(Locate.req, params => {
             logger.debug `received request ${'locate'}, ${params}`;
             switch (true) {
                 case 'element' in params:
@@ -169,7 +181,7 @@ export class Rpc extends ADisposable {
                 default:
                     nonexhaustive(params);
             }
-        }), connection.onRequest(ChangeView.Req, async (request, _cancelToken) => {
+        }), connection.onRequest(ChangeView.req, async (request, _cancelToken) => {
             logger.debug `received request ${'changeView'} of ${request.viewId} from project ${request.projectId}`;
             return await likec4Services.ModelChanges.applyChange(request);
         }), connection.onRequest(FetchTelemetryMetrics.req, async (cancelToken) => {

package/dist/ast.js

@@ -1,4 +1,4 @@
-import { MultiMap, nonexhaustive } from '@likec4/core/utils';
+import { invariant, MultiMap, nonexhaustive } from '@likec4/core/utils';
 import { AstUtils, DocumentState } from 'langium';
 import { clamp, isNullish, isTruthy } from 'remeda';
 import * as ast from './generated/ast';
@@ -29,7 +29,11 @@ export const ElementOps = {
     },
 };
 export function isLikeC4LangiumDocument(doc) {
-    return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
+    if (doc.textDocument.languageId === LikeC4LanguageMetaData.languageId) {
+        invariant(isTruthy(doc.likec4ProjectId), `LikeC4Document must have projectId defined: ${doc.uri.fsPath}`);
+        return true;
+    }
+    return false;
 }
 export function isParsedLikeC4LangiumDocument(doc) {
     return (isLikeC4LangiumDocument(doc)

package/dist/browser.js

@@ -1,4 +1,4 @@
-import { configureLogger, getAnsiColorFormatter, getConsoleSink } from '@likec4/log';
+import { configureLogger, getConsoleSink, getTextFormatter } from '@likec4/log';
 import { startLanguageServer as startLanguim } from 'langium/lsp';
 import { BrowserMessageReader, BrowserMessageWriter, createConnection } from 'vscode-languageserver/browser';
 import { createLanguageServices } from './module';
@@ -12,7 +12,7 @@ export function startLanguageServer(port) {
     configureLogger({
         sinks: {
             console: getConsoleSink({
-                formatter: getAnsiColorFormatter({
+                formatter: getTextFormatter({
                     format: ({ level, category, message }) => {
                         return `${level} ${category} ${message}`;
                     },

package/dist/bundled.js

@@ -6,6 +6,7 @@ import { getLspConnectionSink, logger } from './logger';
 import { WithMCPServer } from './mcp/server/WithMCPServer';
 import { createLanguageServices } from './module';
 import { ConfigurableLayouter } from './views/ConfigurableLayouter';
+import { WithLikeC4ManualLayouts } from './views/LikeC4ManualLayouts';
 /**
  * This is used as `bin` entry point to start the language server.
  */
@@ -35,6 +36,7 @@ export function startLanguageServer() {
         connection,
         ...LikeC4FileSystem(false),
         ...WithMCPServer('sse'),
+        ...WithLikeC4ManualLayouts,
     }, ConfigurableLayouter);
     // Start the language server with the shared services
     startLanguim(services.shared);