@likec4/language-server 1.40.0 → 1.42.0

package/dist/test/testServices.mjs

@@ -25,31 +25,29 @@ export function createTestServices(options) {
   async function initialize() {
     if (isInitialized) return;
     isInitialized = true;
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      services.shared.workspace.ConfigurationProvider.updateConfiguration({
-        settings: { likec4: { formatting: { quoteStyle: "single" } } }
-      });
-      services.shared.workspace.WorkspaceManager.initialize({
-        capabilities: {},
-        processId: null,
-        rootUri: workspaceFolder.uri,
-        workspaceFolders: [workspaceFolder]
-      });
-      await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
-      if (projectConfig) {
-        const projectFolderUri = Utils.resolvePath(workspaceUri, "src");
-        services.shared.workspace.ProjectsManager.registerProject({
-          config: {
-            name: projectConfig?.name || "test-project",
-            title: projectConfig?.title || "Test Project",
-            contactPerson: projectConfig?.contactPerson || "Unknown",
-            imageAliases: projectConfig?.imageAliases || {},
-            exclude: projectConfig?.exclude || ["node_modules"]
-          },
-          folderUri: projectFolderUri
-        });
-      }
+    services.shared.workspace.ConfigurationProvider.updateConfiguration({
+      settings: { likec4: { formatting: { quoteStyle: "single" } } }
     });
+    services.shared.workspace.WorkspaceManager.initialize({
+      capabilities: {},
+      processId: null,
+      rootUri: workspaceFolder.uri,
+      workspaceFolders: [workspaceFolder]
+    });
+    await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+    if (projectConfig) {
+      const projectFolderUri = Utils.resolvePath(workspaceUri, "src");
+      await services.shared.workspace.ProjectsManager.registerProject({
+        config: {
+          name: projectConfig?.name || "test-project",
+          title: projectConfig?.title || "Test Project",
+          contactPerson: projectConfig?.contactPerson || "Unknown",
+          imageAliases: projectConfig?.imageAliases || {},
+          exclude: projectConfig?.exclude || ["node_modules"]
+        },
+        folderUri: projectFolderUri
+      });
+    }
   }
   const addDocument = async (input, uri) => {
     await initialize();
@@ -65,18 +63,18 @@ export function createTestServices(options) {
     langiumDocuments.addDocument(document);
     return document;
   };
+  const removeDocument = async (doc) => {
+    const uri = doc instanceof URI ? doc : doc.uri;
+    await documentBuilder.update([], [uri]);
+  };
   const parse = async (input, uri) => {
     const document = await addDocument(input, uri);
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: false });
-    });
+    await documentBuilder.build([document], { validation: false });
     return document;
   };
   const validate = async (input, uri) => {
     const document = typeof input === "string" ? await addDocument(input, uri) : input;
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: true });
-    });
+    await documentBuilder.build([document], { validation: true });
     const diagnostics = document.diagnostics ?? [];
     const warnings = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Warning ? d.message : []);
     const errors = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Error ? d.message : []);
@@ -88,10 +86,8 @@ export function createTestServices(options) {
     };
   };
   const format = async (input, uri) => {
-    const document = typeof input === "string" ? await parse(input, uri) : input;
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: true });
-    });
+    const document = typeof input === "string" ? await parse(stripIndent(input), uri) : input;
+    await documentBuilder.build([document], { validation: true });
     const edits = await formatter?.formatDocument(
       document,
       {
@@ -139,6 +135,7 @@ export function createTestServices(options) {
   return {
     services,
     addDocument,
+    removeDocument,
     parse,
     validate,
     validateAll,
@@ -158,7 +155,7 @@ export async function createMultiProjectTestServices(data) {
   const projects = {};
   for (const [name, files] of entries(data)) {
     const folderUri = UriUtils.joinPath(URI.parse(workspace), "src", name);
-    services.shared.workspace.ProjectsManager.registerProject({
+    await services.shared.workspace.ProjectsManager.registerProject({
       config: {
         name,
         exclude: ["node_modules"]

package/dist/utils/disposable.mjs

@@ -1,4 +1,4 @@
-import { logError } from "../logger.mjs";
+import { logWarnError } from "../logger.mjs";
 export class ADisposable {
   toDispose = [];
   isDisposed = false;
@@ -13,7 +13,7 @@ export class ADisposable {
       try {
         item.dispose();
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }

package/dist/utils/index.mjs

@@ -16,7 +16,7 @@ export function safeCall(fn) {
 export function performanceNow() {
   try {
     return performance.now();
-  } catch (e) {
+  } catch {
     return Date.now();
   }
 }

package/dist/validation/_shared.d.ts

@@ -1,3 +1,3 @@
-import { type AstNode, type ValidationCheck } from 'langium';
+import type { AstNode, ValidationCheck } from 'langium';
 export declare const RESERVED_WORDS: string[];
 export declare function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T>;

package/dist/validation/deployment-checks.d.ts

@@ -4,4 +4,4 @@ import type { LikeC4Services } from '../module';
 export declare const deploymentNodeChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentNode>;
 export declare const deployedInstanceChecks: (services: LikeC4Services) => ValidationCheck<ast.DeployedInstance>;
 export declare const deploymentRelationChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentRelation>;
-export declare const extendDeploymentChecks: (services: LikeC4Services) => ValidationCheck<ast.ExtendDeployment>;
+export declare const extendDeploymentChecks: (_services: LikeC4Services) => ValidationCheck<ast.ExtendDeployment>;

package/dist/validation/deployment-checks.mjs

@@ -1,6 +1,8 @@
 import { FqnRef, isSameHierarchy, nonNullable } from "@likec4/core";
+import { loggable } from "@likec4/log";
 import { AstUtils } from "langium";
 import { ast } from "../ast.mjs";
+import { logger } from "../logger.mjs";
 import { projectIdFrom } from "../utils/index.mjs";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.mjs";
 const { getDocument } = AstUtils;
@@ -88,6 +90,7 @@ export const deploymentRelationChecks = (services) => {
     try {
       sourceFqnRef = parser._resolveDeploymentRelationSource(el);
     } catch (e) {
+      logger.warn(loggable(e));
       accept("error", "DeploymentRelation source not resolved", {
         node: el,
         property: "source"
@@ -130,7 +133,7 @@ export const deploymentRelationChecks = (services) => {
     }
   });
 };
-export const extendDeploymentChecks = (services) => {
+export const extendDeploymentChecks = (_services) => {
   return tryOrLog((el, accept) => {
     const target = el.deploymentNode.value.ref;
     if (!target || !ast.isDeploymentNode(target)) {

package/dist/validation/dynamic-view.d.ts

@@ -1,5 +1,6 @@
 import { type ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
-export declare const dynamicViewStep: (services: LikeC4Services) => ValidationCheck<ast.DynamicViewStep>;
-export declare const dynamicViewDisplayVariant: (services: LikeC4Services) => ValidationCheck<ast.DynamicViewDisplayVariantProperty>;
+export declare const dynamicViewStepSingle: (services: LikeC4Services) => ValidationCheck<ast.DynamicStepSingle>;
+export declare const dynamicViewStepChain: (services: LikeC4Services) => ValidationCheck<ast.DynamicStepChain>;
+export declare const dynamicViewDisplayVariant: (_services: LikeC4Services) => ValidationCheck<ast.DynamicViewDisplayVariantProperty>;

package/dist/validation/dynamic-view.mjs

@@ -4,7 +4,7 @@ import { isEmpty } from "remeda";
 import { ast } from "../ast.mjs";
 import { elementRef } from "../utils/elementRef.mjs";
 import { tryOrLog } from "./_shared.mjs";
-export const dynamicViewStep = (services) => {
+export const dynamicViewStepSingle = (services) => {
   const fqnIndex = services.likec4.FqnIndex;
   return tryOrLog((el, accept) => {
     const sourceEl = elementRef(el.source);
@@ -30,7 +30,26 @@ export const dynamicViewStep = (services) => {
     }
   });
 };
-export const dynamicViewDisplayVariant = (services) => {
+export const dynamicViewStepChain = (services) => {
+  const fqnIndex = services.likec4.FqnIndex;
+  return tryOrLog((el, accept) => {
+    const source = el.source;
+    if (ast.isDynamicStepSingle(source) && source.isBackward) {
+      accept("error", "Invalid chain after backward step", {
+        node: el
+      });
+    }
+    const targetEl = elementRef(el.target);
+    const target = targetEl && fqnIndex.getFqn(targetEl);
+    if (!target) {
+      accept("error", "Target not found (not parsed/indexed yet)", {
+        node: el,
+        property: "target"
+      });
+    }
+  });
+};
+export const dynamicViewDisplayVariant = (_services) => {
   return tryOrLog((prop, accept) => {
     if (isEmpty(prop.value) || prop.value !== "diagram" && prop.value !== "sequence") {
       accept("error", 'Invalid display variant: "diagram" or "sequence" are allowed', {

package/dist/validation/element-ref.d.ts

@@ -1,4 +1,4 @@
-import { type ValidationCheck } from 'langium';
+import type { ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';
-export declare const checkElementRef: (services: LikeC4Services) => ValidationCheck<ast.ElementRef>;
+export declare const checkElementRef: (_services: LikeC4Services) => ValidationCheck<ast.ElementRef>;

package/dist/validation/element-ref.mjs

@@ -1,6 +1,6 @@
 import { isReferenceToDeploymentModel } from "../utils/index.mjs";
 import { tryOrLog } from "./_shared.mjs";
-export const checkElementRef = (services) => {
+export const checkElementRef = (_services) => {
   return tryOrLog((el, accept) => {
     if (isReferenceToDeploymentModel(el.modelElement)) {
       accept("error", "Only model elements allowed here", {

package/dist/validation/imports.d.ts

@@ -2,4 +2,3 @@ import { type ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const checkImportsFromPoject: (services: LikeC4Services) => ValidationCheck<ast.ImportsFromPoject>;
-export declare const checkImported: (services: LikeC4Services) => ValidationCheck<ast.Imported>;

package/dist/validation/imports.mjs

@@ -23,8 +23,3 @@ export const checkImportsFromPoject = (services) => {
     }
   });
 };
-export const checkImported = (services) => {
-  const fqnIndex = services.likec4.FqnIndex;
-  return tryOrLog((el, accept) => {
-  });
-};

package/dist/validation/index.d.ts

@@ -4,7 +4,7 @@ import type { LikeC4Services } from '../module';
 export { LikeC4DocumentValidator } from './DocumentValidator';
 type Guard<N extends AstNode> = (n: AstNode) => n is N;
 type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.Imported | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.RelationStringProperty | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.SpecificationRelationshipKind | ast.GlobalStyle | ast.SpecificationColor | ast.NavigateToProperty | ast.DynamicViewStep | ast.ElementRef | ast.DeploymentRelation | ast.Tags | ast.SpecificationDeploymentNodeKind | ast.DynamicViewParallelSteps | ast.GlobalDynamicPredicateGroup | ast.Relation | ast.SpecificationElementKind | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyleGroup | ast.SpecificationTag | ast.ImportsFromPoject | ast.SpecificationRule;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.Imported | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.RelationStringProperty | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.DynamicViewParallelSteps | ast.ElementRef | ast.SpecificationRelationshipKind | ast.GlobalStyle | ast.SpecificationColor | ast.NavigateToProperty | ast.DeploymentRelation | ast.Tags | ast.SpecificationDeploymentNodeKind | ast.GlobalDynamicPredicateGroup | ast.Relation | ast.SpecificationElementKind | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyleGroup | ast.SpecificationTag | ast.ImportsFromPoject | ast.SpecificationRule;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;

package/dist/validation/index.mjs

@@ -1,3 +1,5 @@
+import { onNextTick } from "@likec4/core/utils";
+import { loggable } from "@likec4/log";
 import { DocumentState } from "langium";
 import { isNullish } from "remeda";
 import { DiagnosticSeverity } from "vscode-languageserver-types";
@@ -9,10 +11,10 @@ import {
   deploymentRelationChecks,
   extendDeploymentChecks
 } from "./deployment-checks.mjs";
-import { dynamicViewDisplayVariant, dynamicViewStep } from "./dynamic-view.mjs";
+import { dynamicViewDisplayVariant, dynamicViewStepChain, dynamicViewStepSingle } from "./dynamic-view.mjs";
 import { checkElement } from "./element.mjs";
 import { checkElementRef } from "./element-ref.mjs";
-import { checkImported, checkImportsFromPoject } from "./imports.mjs";
+import { checkImportsFromPoject } from "./imports.mjs";
 import {
   colorLiteralRuleChecks,
   iconPropertyRuleChecks,
@@ -57,7 +59,8 @@ const isValidatableAstNode = validatableAstNodeGuards([
   ast.isFqnExpr,
   ast.isRelationExpr,
   ast.isDynamicViewParallelSteps,
-  ast.isDynamicViewStep,
+  ast.isDynamicStepChain,
+  ast.isDynamicStepSingle,
   ast.isDeploymentViewRule,
   ast.isDeploymentViewRulePredicate,
   ast.isExpressionV2,
@@ -141,7 +144,8 @@ export function registerValidationChecks(services) {
     GlobalPredicateGroup: checkGlobalPredicate(services),
     GlobalDynamicPredicateGroup: checkGlobalPredicate(services),
     GlobalStyleId: checkGlobalStyleId(services),
-    DynamicViewStep: dynamicViewStep(services),
+    DynamicStepSingle: dynamicViewStepSingle(services),
+    DynamicStepChain: dynamicViewStepChain(services),
     LikeC4View: viewChecks(services),
     Element: checkElement(services),
     ElementRef: checkElementRef(services),
@@ -155,20 +159,22 @@ export function registerValidationChecks(services) {
     IncomingRelationExpr: checkIncomingRelationExpr(services),
     OutgoingRelationExpr: checkOutgoingRelationExpr(services),
     ImportsFromPoject: checkImportsFromPoject(services),
-    Imported: checkImported(services),
+    // Imported: checkImported(services),
     ColorLiteral: colorLiteralRuleChecks(services),
     DynamicViewDisplayVariantProperty: dynamicViewDisplayVariant(services)
   });
   const connection = services.shared.lsp.Connection;
   if (connection) {
-    services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
-      for (const uri of deleted) {
-        logger.debug(`clear diagnostics for deleted ${uri.path}`);
-        void connection.sendDiagnostics({
-          uri: uri.toString(),
-          diagnostics: []
-        });
-      }
+    onNextTick(() => {
+      services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
+        for (const uri of deleted) {
+          logger.debug(`clear diagnostics for deleted ${uri.path}`);
+          connection.sendDiagnostics({
+            uri: uri.toString(),
+            diagnostics: []
+          }).catch((e) => logger.error(loggable(e)));
+        }
+      });
     });
   }
 }

package/dist/validation/view-predicates/relation-with.d.ts

@@ -1,4 +1,4 @@
-import { type ValidationCheck } from 'langium';
+import type { ValidationCheck } from 'langium';
 import { ast } from '../../ast';
 import type { LikeC4Services } from '../../module';
 export declare const checkRelationExprWith: (_services: LikeC4Services) => ValidationCheck<ast.RelationExprWith>;

package/dist/validation/view.d.ts

@@ -1,4 +1,4 @@
-import { type ValidationCheck } from 'langium';
+import type { ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.LikeC4View>;

package/dist/view-utils/index.d.ts

@@ -1,2 +1 @@
 export * from './assignNavigateTo';
-export * from './resolve-relative-paths';

package/dist/view-utils/index.mjs

@@ -1,2 +1 @@
 export * from "./assignNavigateTo.mjs";
-export * from "./resolve-relative-paths.mjs";

package/dist/views/likec4-views.d.ts

@@ -44,6 +44,10 @@ export interface LikeC4Views {
 export declare class DefaultLikeC4Views implements LikeC4Views {
     private services;
     private cache;
+    /**
+     * Set of viewIds with reported errors
+     * value is `${projectId}-${viewId}`
+     */
     private viewsWithReportedErrors;
     private ModelBuilder;
     constructor(services: LikeC4Services);
@@ -57,5 +61,7 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
      * Open a view in the preview panel.
      */
     openView(viewId: ViewId, projectId: ProjectId): Promise<void>;
+    private reportViewError;
+    private viewSucceed;
 }
 export {};

package/dist/views/likec4-views.mjs

@@ -1,6 +1,6 @@
 import { loggable } from "@likec4/log";
 import { values } from "remeda";
-import { logError, logger as rootLogger, logWarnError } from "../logger.mjs";
+import { logger as rootLogger, logWarnError } from "../logger.mjs";
 import { performanceMark } from "../utils/index.mjs";
 const viewsLogger = rootLogger.getChild("views");
 export class DefaultLikeC4Views {
@@ -9,6 +9,10 @@ export class DefaultLikeC4Views {
     this.ModelBuilder = services.likec4.ModelBuilder;
   }
   cache = /* @__PURE__ */ new WeakMap();
+  /**
+   * Set of viewIds with reported errors
+   * value is `${projectId}-${viewId}`
+   */
   viewsWithReportedErrors = /* @__PURE__ */ new Set();
   ModelBuilder;
   get layouter() {
@@ -25,10 +29,11 @@ export class DefaultLikeC4Views {
       return [];
     }
     const m0 = performanceMark();
-    const logger = projectId ? viewsLogger.getChild(projectId) : viewsLogger;
+    projectId ??= likeC4Model.project.id;
+    const logger = viewsLogger.getChild(projectId);
     logger.debug`layoutAll: ${views.length} views`;
     const tasks = [];
-    const specification = likeC4Model.$data.specification;
+    const styles = likeC4Model.$styles;
     const results = [];
     for (const view of views) {
       let cached = this.cache.get(view);
@@ -39,15 +44,14 @@ export class DefaultLikeC4Views {
       }
       tasks.push({
         view,
-        specification
+        styles
       });
     }
     if (tasks.length > 0) {
       await this.layouter.batchLayout({
         batch: tasks,
         onSuccess: (task, result) => {
-          this.viewsWithReportedErrors.delete(task.view.id);
-          this.cache.set(task.view, result);
+          this.viewSucceed(task.view, projectId, result);
           results.push(result);
         },
         onError: (task, error) => {
@@ -65,7 +69,8 @@ export class DefaultLikeC4Views {
   async layoutView(viewId, projectId, cancelToken) {
     const model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
     const view = model.findView(viewId)?.$view;
-    const logger = projectId ? viewsLogger.getChild(projectId) : viewsLogger;
+    projectId ??= model.project.id;
+    const logger = viewsLogger.getChild(projectId);
     if (!view) {
       logger.warn`layoutView ${viewId} not found`;
       return null;
@@ -73,25 +78,21 @@ export class DefaultLikeC4Views {
     let cached = this.cache.get(view);
     if (cached) {
       logger.debug`layout ${viewId} from cache`;
-      return await Promise.resolve(cached);
+      return await Promise.resolve().then(() => cached);
     }
     try {
       const m0 = performanceMark();
       const result = await this.layouter.layout({
         view,
-        specification: model.$data.specification
+        styles: model.$styles
       });
-      this.viewsWithReportedErrors.delete(viewId);
-      this.cache.set(view, result);
+      this.viewSucceed(view, projectId, result);
       logger.debug(`layout {viewId} ready in ${m0.pretty}`, { viewId });
       return result;
     } catch (e) {
-      if (!this.viewsWithReportedErrors.has(viewId)) {
-        const errMessage = loggable(e);
-        this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${errMessage}`);
-        this.viewsWithReportedErrors.add(viewId);
-        logError(e);
-      }
+      const errMessage = loggable(e);
+      logger.warn(errMessage);
+      this.reportViewError(view, projectId, errMessage);
       return Promise.reject(e);
     }
   }
@@ -113,7 +114,7 @@ export class DefaultLikeC4Views {
     const tasks = views.map(async (view) => {
       const { dot, svg } = await this.layouter.svg({
         view,
-        specification: likeC4Model.$data.specification
+        styles: likeC4Model.$styles
       });
       return {
         id: view.id,
@@ -139,6 +140,18 @@ export class DefaultLikeC4Views {
   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, projectId, result) {
+    const key = `${projectId}-${view.id}`;
+    this.viewsWithReportedErrors.delete(key);
+    this.cache.set(view, result);
+  }
   // async overviewGraph(): Promise<OverviewGraph> {
   //   const KEY = 'OverviewGraph'
   //   const cache = this.services.ValidatedWorkspaceCache as WorkspaceCache<string, OverviewGraph>

package/dist/workspace/ProjectsManager.d.ts

@@ -1,6 +1,7 @@
-import { type LikeC4ProjectConfig } from '@likec4/config';
-import type { NonEmptyReadonlyArray, ProjectId } from '@likec4/core';
-import { type Cancellation, type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import { type LikeC4ProjectConfig, type LikeC4ProjectConfigInput } from '@likec4/config';
+import type { NonEmptyReadonlyArray } from '@likec4/core';
+import type { 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';
 /**
@@ -10,14 +11,14 @@ import type { LikeC4SharedServices } from '../module';
 export type ProjectFolder = Tagged<string, 'ProjectFolder'>;
 export declare function ProjectFolder(folder: URI | string): ProjectFolder;
 interface ProjectData {
-    id: ProjectId;
+    id: scalar.ProjectId;
     config: LikeC4ProjectConfig;
     folder: ProjectFolder;
     folderUri: URI;
     exclude?: (path: string) => boolean;
 }
 export interface Project {
-    id: ProjectId;
+    id: scalar.ProjectId;
     folderUri: URI;
     config: LikeC4ProjectConfig;
 }
@@ -28,21 +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: ProjectId;
-    private static DefaultProject;
-    /**
-     * The mapping between project config files and project IDs.
-     */
-    private projectIdToFolder;
-    /**
-     * 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.
-     */
-    private _projects;
-    private excludedDocuments;
-    private get defaultGlobalProject();
-    private reloadProjectsLimiter;
+    static readonly DefaultProjectId: scalar.ProjectId;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns:
@@ -51,16 +38,16 @@ export declare class ProjectsManager {
      *  - the ID of the only project
      *  - undefined if there are multiple projects.
      */
-    get defaultProjectId(): ProjectId | undefined;
-    set defaultProjectId(id: ProjectId | undefined);
-    get all(): NonEmptyReadonlyArray<ProjectId>;
-    getProject(arg: ProjectId | LangiumDocument): Project;
+    get defaultProjectId(): scalar.ProjectId | undefined;
+    set defaultProjectId(id: string | scalar.ProjectId | undefined);
+    get all(): NonEmptyReadonlyArray<scalar.ProjectId>;
+    getProject(arg: scalar.ProjectId | LangiumDocument): Project;
     /**
      * 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?: ProjectId | undefined): ProjectId;
+    ensureProjectId(projectId?: scalar.ProjectId | undefined): scalar.ProjectId;
     hasMultipleProjects(): boolean;
     /**
      * Checks if the specified document should be excluded from processing.
@@ -77,20 +64,25 @@ export declare class ProjectsManager {
      *
      * @param entry The file system entry to check
      */
-    loadConfigFile(entry: FileSystemNode): Promise<ProjectData | undefined>;
+    registerConfigFile(configFile: URI): Promise<ProjectData | undefined>;
     /**
      * 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: LikeC4ProjectConfig;
+        config: LikeC4ProjectConfigInput;
         folderUri: URI | string;
     }): Promise<ProjectData>;
-    belongsTo(document: LangiumDocument | URI | string): ProjectId;
-    reloadProjects(token?: Cancellation.CancellationToken): Promise<void>;
-    protected uniqueProjectId(name: string): ProjectId;
+    /**
+     * Registers (or reloads) likec4 project by config file or config object.
+     * If there is some project registered at same folder, it will be reloaded.
+     */
+    private _registerProject;
+    belongsTo(document: LangiumDocument | URI | string): scalar.ProjectId;
+    reloadProjects(): Promise<void>;
+    protected uniqueProjectId(name: string): scalar.ProjectId;
     protected resetProjectIds(): void;
-    protected rebuidDocuments(): Promise<void>;
+    protected rebuidDocuments(cancelToken?: Cancellation.CancellationToken): Promise<void>;
     protected findProjectForDocument(documentUri: string): any;
     protected get mappingsToProject(): WorkspaceCache<string, Pick<ProjectData, 'id' | 'config' | 'exclude'>>;
 }