@likec4/language-server 1.19.0 → 1.19.1

package/dist/Rpc.js

@@ -10,6 +10,7 @@ import {
   computeView,
   fetchComputedModel,
   fetchModel,
+  layoutView,
   locate,
   onDidChangeModel
 } from "./protocol.js";
@@ -22,6 +23,7 @@ export class Rpc {
     const modelBuilder = this.services.likec4.ModelBuilder;
     const modelLocator = this.services.likec4.ModelLocator;
     const modelEditor = this.services.likec4.ModelChanges;
+    const views = this.services.likec4.Views;
     const connection = this.services.shared.lsp.Connection;
     if (!connection) {
       logger.info(`[ServerRpc] no connection, not initializing`);
@@ -64,6 +66,10 @@ export class Rpc {
         const view = await modelBuilder.computeView(viewId, cancelToken);
         return { view };
       }),
+      connection.onRequest(layoutView, async ({ viewId }, cancelToken) => {
+        const result = await views.layoutView(viewId, cancelToken);
+        return { result };
+      }),
       connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
         const changed = docs.map((d) => URI.parse(d));
         const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));

package/dist/browser.d.ts

@@ -3,6 +3,7 @@ export { logger as lspLogger, setLogLevel } from './logger';
 export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module';
 export type { LikeC4Services, LikeC4SharedServices } from './module';
+export type { LikeC4Views } from './views';
 export declare function startLanguageServer(): {
     shared: LikeC4SharedServices;
     likec4: LikeC4Services;

package/dist/documentation/documentation-provider.d.ts

@@ -0,0 +1,8 @@
+import { type AstNode, type DocumentationProvider } from 'langium';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4DocumentationProvider implements DocumentationProvider {
+    private parser;
+    private locator;
+    constructor(services: LikeC4Services);
+    getDocumentation(node: AstNode): string | undefined;
+}

package/dist/documentation/documentation-provider.js

@@ -0,0 +1,46 @@
+import { AstUtils } from "langium";
+import { ast } from "../ast.js";
+import { logWarnError } from "../logger.js";
+export class LikeC4DocumentationProvider {
+  parser;
+  locator;
+  constructor(services) {
+    this.parser = services.likec4.ModelParser;
+    this.locator = services.likec4.ModelLocator;
+  }
+  getDocumentation(node) {
+    try {
+      if (ast.isDeploymentNode(node)) {
+        const doc = AstUtils.getDocument(node);
+        const el = this.parser.forDocument(doc).parseDeploymentNode(node);
+        const lines = [el.id];
+        if (el.title !== node.name) {
+          lines.push(" ", `**${el.title}**`);
+        }
+        return lines.join("  \n");
+      }
+      if (ast.isDeployedInstance(node)) {
+        const doc = AstUtils.getDocument(node);
+        const instance = this.parser.forDocument(doc).parseDeployedInstance(node);
+        const el = this.locator.getParsedElement(instance.element);
+        const lines = [instance.id, `_instance of_ ${instance.element}`];
+        if (el) {
+          lines.push(" ", `**${el.title}**`);
+        }
+        return lines.join("  \n");
+      }
+      if (ast.isElement(node)) {
+        const doc = AstUtils.getDocument(node);
+        const el = this.parser.forDocument(doc).parseElement(node);
+        if (!el) {
+          return;
+        }
+        const lines = [el.id, " ", `**${el.title}**`];
+        return lines.join("  \n");
+      }
+    } catch (e) {
+      logWarnError(e);
+    }
+    return;
+  }
+}

package/dist/documentation/index.d.ts

@@ -0,0 +1 @@
+export { LikeC4DocumentationProvider } from './documentation-provider';

package/dist/documentation/index.js

@@ -0,0 +1 @@
+export { LikeC4DocumentationProvider } from "./documentation-provider.js";

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { logger as lspLogger, setLogLevel } from './logger';
 export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module';
 export type { LikeC4Services, LikeC4SharedServices } from './module';
+export type { LikeC4Views } from './views';
 export { LikeC4FileSystem };
 export declare function startLanguageServer(): {
     shared: LikeC4SharedServices;

package/dist/index.js

@@ -1,13 +1,14 @@
 import { startLanguageServer as startLanguim } from "langium/lsp";
 import { createConnection, ProposedFeatures } from "vscode-languageserver/node";
 import { LikeC4FileSystem } from "./LikeC4FileSystem.js";
-import { createLanguageServices } from "./module.js";
+import { createCustomLanguageServices } from "./module.js";
+import { ConfigurableLayouter } from "./views/configurable-layouter.js";
 export { logger as lspLogger, setLogLevel } from "./logger.js";
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from "./module.js";
 export { LikeC4FileSystem };
 export function startLanguageServer() {
   const connection = createConnection(ProposedFeatures.all);
-  const services = createLanguageServices({ connection, ...LikeC4FileSystem });
+  const services = createCustomLanguageServices({ connection, ...LikeC4FileSystem }, ConfigurableLayouter);
   startLanguim(services.shared);
   return services;
 }

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -1,16 +1,22 @@
 import { type AstNode, type MaybePromise } from 'langium';
 import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp';
 import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types';
-import { ast, type LikeC4LangiumDocument } from '../ast';
+import { type LikeC4LangiumDocument, ast } from '../ast';
+import type { LikeC4ModelLocator, LikeC4ModelParser } from '../model';
 import type { LikeC4Services } from '../module';
+import type { LikeC4NameProvider } from '../references';
 export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
     private services;
     protected readonly nodeKindProvider: NodeKindProvider;
+    protected readonly nameProvider: LikeC4NameProvider;
+    protected readonly parser: LikeC4ModelParser;
+    protected readonly locator: LikeC4ModelLocator;
     constructor(services: LikeC4Services);
-    getSymbols({ parseResult: { value: { specifications, models, views, likec4lib } } }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]>;
+    getSymbols({ parseResult: { value: { specifications, models, deployments, views, likec4lib }, }, }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]>;
     protected getLikec4LibSymbol(astLib: ast.LikeC4Lib): DocumentSymbol[];
     protected getSpecSymbol(astSpec: ast.SpecificationRule): DocumentSymbol[];
     protected getModelSymbol(astModel: ast.Model): DocumentSymbol[];
+    protected getDeploymentModelSymbol(astModel: ast.ModelDeployments): DocumentSymbol[];
     protected getElementsSymbol(el: ast.Element | ast.Relation | ast.ExtendElement): DocumentSymbol[];
     protected getExtendElementSymbol(astElement: ast.ExtendElement): DocumentSymbol[];
     protected getElementSymbol(astElement: ast.Element): DocumentSymbol[];
@@ -19,5 +25,8 @@ export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvi
     protected getTagSymbol(astTag: ast.SpecificationTag): DocumentSymbol | null;
     protected getLibIconSymbol(astTag: ast.LibIcon): DocumentSymbol | null;
     protected getViewSymbol(astView: ast.LikeC4View): DocumentSymbol[];
+    protected getDeploymentElementSymbol(el: ast.DeploymentElement | ast.DeploymentRelation): DocumentSymbol[];
+    protected getDeploymentNodeSymbol(astElement: ast.DeploymentNode): DocumentSymbol[];
+    protected getDeployedInstanceSymbol(astElement: ast.DeployedInstance): DocumentSymbol[];
     protected symbolKind(node: AstNode): SymbolKind;
 }

package/dist/lsp/DocumentSymbolProvider.js

@@ -1,31 +1,38 @@
 import { nonexhaustive } from "@likec4/core";
-import { GrammarUtils } from "langium";
+import { AstUtils, GrammarUtils } from "langium";
 import { filter, isEmpty, isTruthy, map, pipe } from "remeda";
 import { SymbolKind } from "vscode-languageserver-types";
 import { ast } from "../ast.js";
-import { logError } from "../logger.js";
+import { logWarnError } from "../logger.js";
 import { getFqnElementRef } from "../utils/elementRef.js";
 export class LikeC4DocumentSymbolProvider {
   constructor(services) {
     this.services = services;
     this.nodeKindProvider = services.shared.lsp.NodeKindProvider;
+    this.parser = services.likec4.ModelParser;
+    this.locator = services.likec4.ModelLocator;
+    this.nameProvider = services.references.NameProvider;
   }
   nodeKindProvider;
+  nameProvider;
+  parser;
+  locator;
   getSymbols({
     parseResult: {
-      value: { specifications, models, views, likec4lib }
+      value: { specifications, models, deployments, views, likec4lib }
     }
   }) {
     return [
       ...likec4lib.map((l) => () => this.getLikec4LibSymbol(l)),
       ...specifications.map((s) => () => this.getSpecSymbol(s)),
       ...models.map((s) => () => this.getModelSymbol(s)),
+      ...deployments.map((s) => () => this.getDeploymentModelSymbol(s)),
       ...views.map((s) => () => this.getModelViewsSymbol(s))
     ].flatMap((fn) => {
       try {
         return fn() ?? [];
       } catch (e) {
-        logError(e);
+        logWarnError(e);
         return [];
       }
     });
@@ -61,7 +68,7 @@ export class LikeC4DocumentSymbolProvider {
             return this.getTagSymbol(nd);
           }
         } catch (e) {
-          logError(e);
+          logWarnError(e);
           return null;
         }
         nonexhaustive(nd);
@@ -94,6 +101,21 @@ export class LikeC4DocumentSymbolProvider {
       }
     ];
   }
+  getDeploymentModelSymbol(astModel) {
+    const cstModel = astModel.$cstNode;
+    if (!cstModel) return [];
+    const nameNode = GrammarUtils.findNodeForProperty(cstModel, "name");
+    if (!nameNode) return [];
+    return [
+      {
+        kind: this.symbolKind(astModel),
+        name: astModel.name,
+        range: cstModel.range,
+        selectionRange: nameNode.range,
+        children: astModel.elements.flatMap((e) => this.getDeploymentElementSymbol(e))
+      }
+    ];
+  }
   getElementsSymbol(el) {
     try {
       if (ast.isExtendElement(el)) {
@@ -103,7 +125,7 @@ export class LikeC4DocumentSymbolProvider {
         return this.getElementSymbol(el);
       }
     } catch (e) {
-      logError(e);
+      logWarnError(e);
     }
     return [];
   }
@@ -196,6 +218,56 @@ export class LikeC4DocumentSymbolProvider {
       }
     ];
   }
+  getDeploymentElementSymbol(el) {
+    try {
+      if (ast.isDeploymentNode(el)) {
+        return this.getDeploymentNodeSymbol(el);
+      }
+      if (ast.isDeployedInstance(el)) {
+        return this.getDeployedInstanceSymbol(el);
+      }
+    } catch (e) {
+      logWarnError(e);
+    }
+    return [];
+  }
+  getDeploymentNodeSymbol(astElement) {
+    const cst = astElement.$cstNode;
+    const nameNode = this.nameProvider.getNameNode(astElement);
+    if (!nameNode || !cst) return [];
+    const name = this.nameProvider.getNameStrict(astElement);
+    const kind = astElement.kind.$refText;
+    const detail = kind;
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        detail,
+        children: astElement.body?.elements.flatMap((e) => this.getDeploymentElementSymbol(e)) ?? []
+      }
+    ];
+  }
+  getDeployedInstanceSymbol(astElement) {
+    const cst = astElement.$cstNode;
+    const nameNode = this.nameProvider.getNameNode(astElement);
+    if (!nameNode || !cst) return [];
+    const doc = AstUtils.getDocument(astElement);
+    const instance = this.parser.forDocument(doc).parseDeployedInstance(astElement);
+    const name = this.nameProvider.getNameStrict(astElement);
+    const detail = "instance of " + instance.element;
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        detail,
+        children: []
+      }
+    ];
+  }
   symbolKind(node) {
     return this.nodeKindProvider.getSymbolKind(node);
   }

package/dist/model/fqn-computation.js

@@ -1,4 +1,4 @@
-import { AsFqn, nonexhaustive } from "@likec4/core";
+import { AsFqn, LinkedList, nonexhaustive } from "@likec4/core";
 import { AstUtils, CstUtils, GrammarUtils, MultiMap } from "langium";
 import { isDefined, isEmpty } from "remeda";
 import { ast, ElementOps } from "../ast.js";
@@ -29,7 +29,7 @@ export function computeDocumentFqn(document, services) {
     return;
   }
   const locator = services.workspace.AstNodeLocator;
-  const traverseStack = elements.map((el) => [el, null]);
+  const traverseStack = LinkedList.from(elements.map((el) => [el, null]));
   let pair;
   while (pair = traverseStack.shift()) {
     try {

package/dist/model/model-builder.js

@@ -33,7 +33,7 @@ import {
   values
 } from "remeda";
 import { isParsedLikeC4LangiumDocument } from "../ast.js";
-import { logError, logger, logWarnError } from "../logger.js";
+import { logger, logWarnError } from "../logger.js";
 import { assignNavigateTo, resolveRelativePaths } from "../view-utils/index.js";
 function buildModel(services, docs) {
   const c4Specification = {
@@ -542,7 +542,7 @@ export class LikeC4ModelBuilder {
         }
         const result = LikeC4Model.makeCompute(model)(view);
         if (!result.isSuccess) {
-          logError(result.error);
+          logWarnError(result.error);
           return null;
         }
         let computedView = result.view;
@@ -588,7 +588,7 @@ export class LikeC4ModelBuilder {
       try {
         listener(docs);
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }

package/dist/module.d.ts

@@ -1,11 +1,14 @@
+import { GraphvizLayouter } from '@likec4/layouts';
 import { type Module, DocumentCache, WorkspaceCache } from 'langium';
 import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
+import { LikeC4DocumentationProvider } from './documentation';
 import { LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
 import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 import { LikeC4ModelChanges } from './model-change/ModelChanges';
 import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { Rpc } from './Rpc';
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared';
+import { LikeC4Views } from './views';
 interface LikeC4AddedSharedServices {
     lsp: {
         NodeKindProvider: NodeKindProvider;
@@ -20,10 +23,15 @@ export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServ
  * Declaration of custom services - add your own service classes here.
  */
 export interface LikeC4AddedServices {
+    documentation: {
+        DocumentationProvider: LikeC4DocumentationProvider;
+    };
     WorkspaceCache: WorkspaceCache<string, any>;
     DocumentCache: DocumentCache<string, any>;
     Rpc: Rpc;
     likec4: {
+        Views: LikeC4Views;
+        Layouter: GraphvizLayouter;
         DeploymentsIndex: DeploymentsIndex;
         FqnIndex: FqnIndex;
         ModelParser: LikeC4ModelParser;
@@ -50,7 +58,7 @@ export interface LikeC4AddedServices {
 export type LikeC4Services = LangiumServices & LikeC4AddedServices;
 export declare const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
 export type LanguageServicesContext = Partial<DefaultSharedModuleContext>;
-export declare function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: LanguageServicesContext, module: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
+export declare function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: LanguageServicesContext, module?: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
     shared: LikeC4SharedServices;
     likec4: I;
 };

package/dist/module.js

@@ -1,11 +1,21 @@
-import { DocumentCache, EmptyFileSystem, inject, WorkspaceCache } from "langium";
+import { GraphvizLayouter, GraphvizWasmAdapter } from "@likec4/layouts";
+import {
+  DocumentCache,
+  EmptyFileSystem,
+  inject,
+  WorkspaceCache
+} from "langium";
 import {
   createDefaultModule,
   createDefaultSharedModule
 } from "langium/lsp";
+import { LikeC4DocumentationProvider } from "./documentation/index.js";
 import { LikeC4Formatter } from "./formatting/LikeC4Formatter.js";
-import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from "./generated/module.js";
-import { logToLspConnection } from "./logger.js";
+import {
+  LikeC4GeneratedModule,
+  LikeC4GeneratedSharedModule
+} from "./generated/module.js";
+import { logger, logToLspConnection } from "./logger.js";
 import {
   LikeC4CodeLensProvider,
   LikeC4CompletionProvider,
@@ -15,12 +25,27 @@ import {
   LikeC4HoverProvider,
   LikeC4SemanticTokenProvider
 } from "./lsp/index.js";
-import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from "./model/index.js";
+import {
+  DeploymentsIndex,
+  FqnIndex,
+  LikeC4ModelBuilder,
+  LikeC4ModelLocator,
+  LikeC4ModelParser
+} from "./model/index.js";
 import { LikeC4ModelChanges } from "./model-change/ModelChanges.js";
-import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from "./references/index.js";
+import {
+  LikeC4NameProvider,
+  LikeC4ScopeComputation,
+  LikeC4ScopeProvider
+} from "./references/index.js";
 import { Rpc } from "./Rpc.js";
-import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from "./shared/index.js";
+import {
+  LikeC4WorkspaceManager,
+  NodeKindProvider,
+  WorkspaceSymbolProvider
+} from "./shared/index.js";
 import { registerValidationChecks } from "./validation/index.js";
+import { LikeC4Views } from "./views/index.js";
 const LikeC4SharedModule = {
   lsp: {
     NodeKindProvider: (services) => new NodeKindProvider(services),
@@ -34,10 +59,18 @@ function bind(Type) {
   return (services) => new Type(services);
 }
 export const LikeC4Module = {
+  documentation: {
+    DocumentationProvider: bind(LikeC4DocumentationProvider)
+  },
   WorkspaceCache: (services) => new WorkspaceCache(services.shared),
   DocumentCache: (services) => new DocumentCache(services.shared),
   Rpc: bind(Rpc),
   likec4: {
+    Layouter: (_services) => {
+      logger.debug("Creating GraphvizLayouter with GraphvizWasmAdapter");
+      return new GraphvizLayouter(new GraphvizWasmAdapter());
+    },
+    Views: bind(LikeC4Views),
     DeploymentsIndex: bind(DeploymentsIndex),
     ModelChanges: bind(LikeC4ModelChanges),
     FqnIndex: bind(FqnIndex),
@@ -98,10 +131,16 @@ export function createSharedServices(context = {}) {
 }
 export function createLanguageServices(context = {}) {
   const shared = createSharedServices(context);
-  const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
+  const likec4 = inject(
+    createDefaultModule({ shared }),
+    LikeC4GeneratedModule,
+    LikeC4Module
+  );
   shared.ServiceRegistry.register(likec4);
   registerValidationChecks(likec4);
-  if (context.connection) {
+  if (!context.connection) {
+    shared.workspace.ConfigurationProvider.initialized({});
+  } else {
     likec4.Rpc.init();
   }
   return { shared, likec4 };

package/dist/protocol.d.ts

@@ -1,4 +1,4 @@
-import type { ComputedLikeC4Model, ComputedView, Fqn, ParsedLikeC4Model, RelationId, ViewChange, ViewId } from '@likec4/core';
+import type { ComputedLikeC4Model, ComputedView, DiagramView, Fqn, ParsedLikeC4Model, RelationId, ViewChange, ViewId } from '@likec4/core';
 import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
 import type { DocumentUri, Location } from 'vscode-languageserver-types';
 export declare const onDidChangeModel: NotificationType<string>;
@@ -19,11 +19,29 @@ export declare const computeView: RequestType<{
     view: ComputedView | null;
 }, void>;
 export type ComputeViewRequest = typeof computeView;
+/**
+ * Request to layout a view.
+ */
+export declare const layoutView: RequestType<{
+    viewId: ViewId;
+}, {
+    result: {
+        dot: string;
+        diagram: DiagramView;
+    } | null;
+}, void>;
+export type LayoutViewRequest = typeof layoutView;
+/**
+ * Request to build documents.
+ */
 export interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
 export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
 export type BuildDocumentsRequest = typeof buildDocuments;
+/**
+ * Request to locate an element, relation, deployment or view.
+ */
 export type LocateParams = {
     element: Fqn;
     property?: string;

package/dist/protocol.js

@@ -9,6 +9,7 @@ export const fetchComputedModel = new RequestType(
 export const computeView = new RequestType(
   "likec4/computeView"
 );
+export const layoutView = new RequestType("likec4/layout-view");
 export const buildDocuments = new RequestType("likec4/build");
 export const locate = new RequestType("likec4/locate");
 export const changeView = new RequestType("likec4/change-view");

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

@@ -1,6 +1,6 @@
-import { type AstNodeDescription, DefaultScopeComputation, type PrecomputedScopes } from 'langium';
+import { type AstNodeDescription, type PrecomputedScopes, DefaultScopeComputation } from 'langium';
 import type { CancellationToken } from 'vscode-languageserver';
-import { ast, type LikeC4LangiumDocument } from '../ast';
+import { type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
 type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody;

package/dist/references/scope-computation.js

@@ -5,7 +5,7 @@ import {
 } from "langium";
 import { entries, filter, flatMap, forEachObj, groupBy, isNullish, isTruthy, pipe } from "remeda";
 import { ast } from "../ast.js";
-import { logError, logWarnError } from "../logger.js";
+import { logWarnError } from "../logger.js";
 function uniqueDescriptions(descs) {
   return pipe(
     descs,
@@ -29,7 +29,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       this.exportGlobals(globals, docExports, document);
       this.exportDeployments(deployments, docExports, document);
     } catch (e) {
-      logError(e);
+      logWarnError(e);
     }
     return docExports;
   }
@@ -44,7 +44,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }
@@ -59,7 +59,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(id, id.name, document));
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
     for (const globalStyleAst of globals.flatMap((g) => g.styles)) {
@@ -69,7 +69,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(id, id.name, document));
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }
@@ -83,7 +83,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }
@@ -96,7 +96,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document));
       }
     } catch (e) {
-      logError(e);
+      logWarnError(e);
     }
   }
   exportSpecification(specifications, docExports, document) {
@@ -151,7 +151,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
             nonexhaustive(spec);
         }
       } catch (e) {
-        logError(e);
+        logWarnError(e);
       }
     }
   }
@@ -181,7 +181,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
             ...this.processContainer(model, scopes, document)
           );
         } catch (e) {
-          logError(e);
+          logWarnError(e);
         }
       }
       for (const deployment of root.deployments) {

package/dist/validation/dynamic-view-rule.js

@@ -1,6 +1,7 @@
 import { ast, elementExpressionFromPredicate } from "../ast.js";
+import { tryOrLog } from "./_shared.js";
 export const dynamicViewRulePredicate = (_services) => {
-  return (predicate, accept) => {
+  return tryOrLog((predicate, accept) => {
     const expr = elementExpressionFromPredicate(predicate.value);
     switch (true) {
       case ast.isElementKindExpression(expr):
@@ -12,5 +13,5 @@ export const dynamicViewRulePredicate = (_services) => {
         return;
       }
     }
-  };
+  });
 };