@likec4/language-server 1.27.3 → 1.28.1

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

@@ -25,6 +25,7 @@ export declare class DefaultLikeC4Views implements LikeC4Views {
     private cache;
     private viewsWithReportedErrors;
     private ModelBuilder;
+    private queue;
     constructor(services: LikeC4Services);
     get layouter(): GraphvizLayouter;
     computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;

package/dist/views/likec4-views.js

@@ -1,9 +1,9 @@
 import { loggable } from "@likec4/log";
+import PQueue from "p-queue";
 import prettyMs from "pretty-ms";
 import { values } from "remeda";
 import { CancellationToken } from "vscode-jsonrpc";
 import { logError, logger as rootLogger, logWarnError } from "../logger.js";
-const logger = rootLogger.getChild("Views");
 export class DefaultLikeC4Views {
   constructor(services) {
     this.services = services;
@@ -12,6 +12,7 @@ export class DefaultLikeC4Views {
   cache = /* @__PURE__ */ new WeakMap();
   viewsWithReportedErrors = /* @__PURE__ */ new Set();
   ModelBuilder;
+  queue = new PQueue({ concurrency: 4, timeout: 1e4, throwOnTimeout: true });
   get layouter() {
     return this.services.likec4.Layouter;
   }
@@ -24,19 +25,28 @@ export class DefaultLikeC4Views {
     if (views.length === 0) {
       return [];
     }
+    const logger = rootLogger.getChild(["views", projectId ?? ""]);
     logger.debug`layoutAll: ${views.length} views`;
     const results = [];
     const tasks = [];
     for (const view of views) {
       this.viewsWithReportedErrors.delete(view.id);
       tasks.push(
-        this.layouter.layout(view).then((result) => {
+        Promise.resolve().then(async () => {
+          const result = await this.queue.add(async () => {
+            logger.debug`layouting view ${view.id}...`;
+            return await this.layouter.layout(view);
+          });
+          if (!result) {
+            return Promise.reject(new Error(`Failed to layout view ${view.id}`));
+          }
+          logger.debug`done layout view ${view.id}`;
           this.viewsWithReportedErrors.delete(view.id);
           this.cache.set(view, result);
           return result;
         }).catch((e) => {
+          logger.warn(`fail layout view ${view.id}`, { e });
           this.cache.delete(view);
-          logWarnError(e);
           return Promise.reject(e);
         })
       );
@@ -44,6 +54,8 @@ export class DefaultLikeC4Views {
     for (const task of await Promise.allSettled(tasks)) {
       if (task.status === "fulfilled") {
         results.push(task.value);
+      } else {
+        logger.error(loggable(task.reason));
       }
     }
     if (results.length !== views.length) {
@@ -56,6 +68,7 @@ export class DefaultLikeC4Views {
   async layoutView(viewId, projectId, cancelToken = CancellationToken.None) {
     const model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
     const view = model.findView(viewId)?.$view;
+    const logger = rootLogger.getChild(["views", projectId ?? ""]);
     if (!view) {
       logger.warn`layoutView ${viewId} not found`;
       return null;
@@ -67,7 +80,13 @@ export class DefaultLikeC4Views {
     }
     try {
       const start = performance.now();
-      const result = await this.layouter.layout(view);
+      const result = await this.queue.add(async () => {
+        logger.debug`layouting view ${view.id}...`;
+        return await this.layouter.layout(view);
+      });
+      if (!result) {
+        throw new Error(`Failed to layout view ${viewId}`);
+      }
       this.viewsWithReportedErrors.delete(viewId);
       this.cache.set(view, result);
       logger.debug(`layout {viewId} ready in ${prettyMs(performance.now() - start)}`, { viewId });

package/dist/workspace/AstNodeDescriptionProvider.d.ts

@@ -1,7 +1,7 @@
 import { type AstNode, type AstNodeDescription, type LangiumDocument, DefaultAstNodeDescriptionProvider } from 'langium';
 import type { LikeC4Services } from '../module';
 export declare class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
-    private projects;
+    protected services: LikeC4Services;
     constructor(services: LikeC4Services);
     createDescription(node: AstNode, name: string | undefined, document?: LangiumDocument): AstNodeDescription;
 }

package/dist/workspace/AstNodeDescriptionProvider.js

@@ -3,15 +3,14 @@ import {
   DefaultAstNodeDescriptionProvider
 } from "langium";
 export class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
-  projects;
   constructor(services) {
     super(services);
-    this.projects = services.shared.workspace.ProjectsManager;
+    this.services = services;
   }
   createDescription(node, name, document) {
     const doc = document ?? AstUtils.getDocument(node);
     const description = super.createDescription(node, name, document);
-    doc.likec4ProjectId ??= this.projects.belongsTo(doc.uri);
+    doc.likec4ProjectId ??= this.services.shared.workspace.ProjectsManager.belongsTo(doc.uri);
     description.likec4ProjectId = doc.likec4ProjectId;
     return description;
   }

package/dist/workspace/IndexManager.d.ts

@@ -3,7 +3,7 @@ import { type AstNodeDescription, type LangiumDocument, type Stream, DefaultInde
 import { CancellationToken } from 'vscode-jsonrpc';
 import type { LikeC4SharedServices } from '../module';
 export declare class IndexManager extends DefaultIndexManager {
-    private projects;
+    protected services: LikeC4SharedServices;
     constructor(services: LikeC4SharedServices);
     updateContent(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
     projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;

package/dist/workspace/IndexManager.js

@@ -1,17 +1,18 @@
 import { DefaultIndexManager, stream } from "langium";
 import { CancellationToken } from "vscode-jsonrpc";
 export class IndexManager extends DefaultIndexManager {
-  projects;
   constructor(services) {
     super(services);
-    this.projects = services.workspace.ProjectsManager;
+    this.services = services;
   }
   async updateContent(document, cancelToken = CancellationToken.None) {
-    document.likec4ProjectId = this.projects.belongsTo(document.uri);
+    const projects = this.services.workspace.ProjectsManager;
+    document.likec4ProjectId = projects.belongsTo(document.uri);
     await super.updateContent(document, cancelToken);
   }
   projectElements(projectId, nodeType, uris) {
+    const projects = this.services.workspace.ProjectsManager;
     let documentUris = stream(this.symbolIndex.keys());
-    return documentUris.filter((uri) => this.projects.belongsTo(uri) === projectId && (!uris || uris.has(uri))).flatMap((uri) => this.getFileDescriptions(uri, nodeType));
+    return documentUris.filter((uri) => projects.belongsTo(uri) === projectId && (!uris || uris.has(uri))).flatMap((uri) => this.getFileDescriptions(uri, nodeType));
   }
 }

package/dist/workspace/LangiumDocuments.d.ts

@@ -3,7 +3,7 @@ import { type Stream, DefaultLangiumDocuments } from 'langium';
 import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4SharedServices } from '../module';
 export declare class LangiumDocuments extends DefaultLangiumDocuments {
-    private projects;
+    protected services: LikeC4SharedServices;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns all user documents, excluding built-in documents.

package/dist/workspace/LangiumDocuments.js

@@ -3,22 +3,20 @@ import { groupBy, prop } from "remeda";
 import { isLikeC4LangiumDocument } from "../ast.js";
 import { isLikeC4Builtin } from "../likec4lib.js";
 export class LangiumDocuments extends DefaultLangiumDocuments {
-  projects;
   constructor(services) {
     super(services);
-    this.projects = services.workspace.ProjectsManager;
+    this.services = services;
   }
   /**
    * 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;
       }
-      if (!doc.likec4ProjectId) {
-        doc.likec4ProjectId = this.projects.belongsTo(doc.uri);
-      }
+      doc.likec4ProjectId ??= projects.belongsTo(doc.uri);
       return true;
     });
   }

package/dist/workspace/ProjectsManager.d.ts

@@ -1,7 +1,14 @@
 import type { NonEmptyReadonlyArray, ProjectId } from '@likec4/core';
 import { type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import picomatch from 'picomatch/posix';
 import { ProjectConfig } from '../config';
 import type { LikeC4SharedServices } from '../module';
+interface Project {
+    id: ProjectId;
+    config: ProjectConfig;
+    folder: string;
+    exclude?: picomatch.Matcher;
+}
 export declare class ProjectsManager {
     protected services: LikeC4SharedServices;
     /**
@@ -14,35 +21,46 @@ export declare class ProjectsManager {
      * The mapping between project config files and project IDs.
      */
     private projectIdToFolder;
-    private _mappingsToProject;
     /**
      * 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 defaultGlobalProject;
     constructor(services: LikeC4SharedServices);
+    /**
+     * Returns:
+     *  - the default project ID if there are no projects.
+     *  - the ID of the only project
+     *  - undefined if there are multiple projects.
+     */
     get defaultProjectId(): ProjectId | undefined;
     get all(): NonEmptyReadonlyArray<ProjectId>;
-    getProject(projectId: ProjectId): {
+    getProject(arg: ProjectId | LangiumDocument): {
+        id: ProjectId;
         folder: URI;
         config: Readonly<ProjectConfig>;
     };
     ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
     hasMultipleProjects(): boolean;
+    checkIfExcluded(documentUri: URI): boolean;
+    isConfigFile(entry: FileSystemNode): boolean;
     /**
      * Checks if the provided file system entry is a valid project config file.
      *
      * @param entry The file system entry to check
      * @returns {boolean} Returns true if the entry is a valid config file, false otherwise.
      */
-    loadConfigFile(entry: FileSystemNode): Promise<boolean>;
-    registerProject(configFile: URI): Promise<void>;
+    loadConfigFile(entry: FileSystemNode): Promise<Project | undefined>;
+    registerProject(configFile: URI): Promise<Project>;
     registerProject(opts: {
         config: ProjectConfig;
         folderUri: URI | string;
-    }): Promise<void>;
+    }): Promise<Project>;
     belongsTo(document: LangiumDocument | URI | string): ProjectId;
-    private getProjectId;
-    protected get mappingsToProject(): WorkspaceCache<string, ProjectId>;
+    protected findProjectForDocument(documentUri: string): Omit<Project, 'folder'>;
+    private _mappingsToProject;
+    protected get mappingsToProject(): WorkspaceCache<string, Omit<Project, 'folder'>>;
 }
+export {};

package/dist/workspace/ProjectsManager.js

@@ -1,7 +1,14 @@
 import { BiMap, invariant, nonNullable } from "@likec4/core";
 import { URI, WorkspaceCache } from "langium";
-import { hasAtLeast, map, pipe, prop, sortBy } from "remeda";
-import { hasProtocol, joinRelativeURL, parseFilename, withoutProtocol, withProtocol } from "ufo";
+import picomatch from "picomatch/posix";
+import { hasAtLeast, isNullish, map, pipe, prop, sortBy } from "remeda";
+import {
+  hasProtocol,
+  joinRelativeURL,
+  parseFilename,
+  withoutProtocol,
+  withProtocol
+} from "ufo";
 import { parseConfigJson } from "../config/index.js";
 import { logger as mainLogger } from "../logger.js";
 const logger = mainLogger.getChild("ProjectsManager");
@@ -24,14 +31,26 @@ export class ProjectsManager {
    * The mapping between project config files and project IDs.
    */
   projectIdToFolder = new BiMap();
-  // The mapping between document URIs and their corresponding project IDs.
-  _mappingsToProject;
   /**
    * 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.
    */
   _projects = [];
+  defaultGlobalProject = {
+    id: ProjectsManager.DefaultProjectId,
+    config: {
+      name: ProjectsManager.DefaultProjectId,
+      exclude: ["**/node_modules/**/*"]
+    },
+    exclude: picomatch("**/node_modules/**/*")
+  };
+  /**
+   * Returns:
+   *  - the default project ID if there are no projects.
+   *  - the ID of the only project
+   *  - undefined if there are multiple projects.
+   */
   get defaultProjectId() {
     if (this._projects.length > 1) {
       return void 0;
@@ -47,20 +66,24 @@ export class ProjectsManager {
     }
     return [ProjectsManager.DefaultProjectId];
   }
-  getProject(projectId) {
-    if (projectId === ProjectsManager.DefaultProjectId) {
-      const folder = this.services.workspace.WorkspaceManager.workspaceUri;
+  getProject(arg) {
+    const id = typeof arg === "string" ? arg : arg.likec4ProjectId || this.belongsTo(arg);
+    if (id === ProjectsManager.DefaultProjectId) {
+      const folder2 = this.services.workspace.WorkspaceManager.workspaceUri;
       return {
-        folder,
-        config: {
-          name: ProjectsManager.DefaultProjectId
-        }
+        id,
+        folder: folder2,
+        config: this.defaultGlobalProject.config
       };
     }
-    const project = nonNullable(this._projects.find(({ id }) => id === projectId), `Project "${projectId}" not found`);
+    const {
+      config,
+      folder
+    } = nonNullable(this._projects.find((p) => p.id === id), `Project "${id}" not found`);
     return {
-      folder: URI.parse(project.folder),
-      config: project.config
+      id,
+      folder: URI.parse(folder),
+      config
     };
   }
   ensureProjectId(projectId) {
@@ -79,6 +102,15 @@ export class ProjectsManager {
   hasMultipleProjects() {
     return this._projects.length > 1;
   }
+  checkIfExcluded(documentUri) {
+    let docUriAsString = documentUri.toString();
+    const project = this.findProjectForDocument(docUriAsString);
+    return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+  }
+  isConfigFile(entry) {
+    const filename = parseFilename(entry.uri.toString(), { strict: false })?.toLowerCase();
+    return !!filename && ProjectsManager.ConfigFileNames.includes(filename);
+  }
   /**
    * Checks if the provided file system entry is a valid project config file.
    *
@@ -87,17 +119,12 @@ export class ProjectsManager {
    */
   async loadConfigFile(entry) {
     if (entry.isDirectory) {
-      return false;
-    }
-    const filename = parseFilename(entry.uri.fsPath, { strict: false });
-    if (!filename) {
-      return false;
+      return void 0;
     }
-    if (ProjectsManager.ConfigFileNames.includes(filename)) {
-      await this.registerProject(entry.uri);
-      return true;
+    if (this.isConfigFile(entry)) {
+      return await this.registerProject(entry.uri);
     }
-    return false;
+    return void 0;
   }
   async registerProject(opts) {
     if (URI.isUri(opts)) {
@@ -109,9 +136,10 @@ export class ProjectsManager {
       return this.registerProject({ config: config2, folderUri: folderUri2 });
     }
     const { config, folderUri } = opts;
-    const id = config.name;
-    if (this._projects.some(({ id: existingId }) => existingId === id)) {
-      throw new Error(`Project ID ${id} already registered`);
+    let id = config.name;
+    let i = 1;
+    while (this.projectIdToFolder.has(id)) {
+      id = `${config.name}-${i++}`;
     }
     let folder;
     if (URI.isUri(folderUri)) {
@@ -119,14 +147,25 @@ export class ProjectsManager {
     } else {
       folder = hasProtocol(folderUri) ? folderUri : withProtocol(folderUri, "file://");
     }
+    const project = {
+      id,
+      config,
+      folder
+    };
+    if (isNullish(config.exclude)) {
+      project.exclude = this.defaultGlobalProject.exclude;
+    } else if (hasAtLeast(config.exclude, 1)) {
+      project.exclude = picomatch(config.exclude);
+    }
     this._projects = pipe(
-      [...this._projects, { folder, config, id }],
+      [...this._projects, project],
       sortBy(
         [({ folder: folder2 }) => withoutProtocol(folder2).split("/").length, "desc"]
       )
     );
     this.projectIdToFolder.set(id, folder);
-    logger.debug`registered project ${id} folder: ${folder})`;
+    logger.info`register project ${id} folder: ${folder})`;
+    return project;
   }
   belongsTo(document) {
     let documentUri;
@@ -137,12 +176,17 @@ export class ProjectsManager {
     } else {
       documentUri = document.uri.toString();
     }
-    return this.mappingsToProject.get(documentUri, () => this.getProjectId(documentUri));
+    return this.findProjectForDocument(documentUri).id;
   }
-  getProjectId(documentUri) {
-    const project = this._projects.find(({ folder }) => documentUri.toString().startsWith(folder));
-    return project?.id ?? ProjectsManager.DefaultProjectId;
+  findProjectForDocument(documentUri) {
+    return this.mappingsToProject.get(documentUri, () => {
+      const project = this._projects.find(({ folder }) => documentUri.startsWith(folder));
+      return project ?? this.defaultGlobalProject;
+    });
   }
+  // The mapping between document URIs and their corresponding project ID
+  // Lazy-created due to initialization order of the LanguageServer
+  _mappingsToProject;
   get mappingsToProject() {
     this._mappingsToProject ??= new WorkspaceCache(this.services);
     return this._mappingsToProject;

package/dist/workspace/WorkspaceManager.d.ts

@@ -1,11 +1,11 @@
-import type { LangiumDocument } from 'langium';
+import type { FileSystemNode, LangiumDocument } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
 import type { WorkspaceFolder } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import type { LikeC4SharedServices } from '../module';
 export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+    private services;
     private documentFactory;
-    private projects;
     constructor(services: LikeC4SharedServices);
     /**
      * Load all additional documents that shall be visible in the context of the given workspace
@@ -14,10 +14,9 @@ export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      */
     protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
     /**
-     * We override the default implementation to process project config files during the traversal.
-     * This is necessary to ensure that the project config files are loaded and processed correctly.
+     * Determine whether the given folder entry shall be included while indexing the workspace.
      */
-    protected traverseFolder(workspaceFolder: WorkspaceFolder, folderPath: URI, fileExtensions: string[], collector: (document: LangiumDocument) => void): Promise<void>;
+    protected includeEntry(_workspaceFolder: WorkspaceFolder, entry: FileSystemNode, fileExtensions: string[]): boolean;
     workspace(): any;
     get workspaceUri(): URI;
     get workspaceURL(): URL;

package/dist/workspace/WorkspaceManager.js

@@ -2,42 +2,75 @@ import { hasAtLeast, invariant } from "@likec4/core";
 import { DefaultWorkspaceManager } from "langium";
 import { URI } from "vscode-uri";
 import * as BuiltIn from "../likec4lib.js";
+import { logError } from "../logger.js";
 export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-  documentFactory;
-  projects;
   constructor(services) {
     super(services);
+    this.services = services;
     this.documentFactory = services.workspace.LangiumDocumentFactory;
-    this.projects = services.workspace.ProjectsManager;
   }
+  documentFactory;
   /**
    * Load all additional documents that shall be visible in the context of the given workspace
    * folders and add them to the collector. This can be used to include built-in libraries of
    * your language, which can be either loaded from provided files or constructed in memory.
    */
   async loadAdditionalDocuments(folders, collector) {
+    const projects = this.services.workspace.ProjectsManager;
+    for (const folder of folders) {
+      try {
+        const content = await this.fileSystemProvider.readDirectory(URI.parse(folder.uri));
+        for (const entry of content) {
+          try {
+            await projects.loadConfigFile(entry);
+          } catch (error) {
+            logError(error);
+          }
+        }
+      } catch (error) {
+        logError(error);
+      }
+    }
     collector(this.documentFactory.fromString(BuiltIn.Content, URI.parse(BuiltIn.Uri)));
     await super.loadAdditionalDocuments(folders, collector);
   }
+  // /**
+  //  * We override the default implementation to process project config files during the traversal.
+  //  * This is necessary to ensure that the project config files are loaded and processed correctly.
+  //  */
+  // protected override async traverseFolder(
+  //   workspaceFolder: WorkspaceFolder,
+  //   folderPath: URI,
+  //   fileExtensions: string[],
+  //   collector: (document: LangiumDocument) => void,
+  // ): Promise<void> {
+  //   // Then load other files
+  //   for (const entry of nonConfigFiles) {
+  //     try {
+  //       if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {
+  //         if (entry.isDirectory) {
+  //           await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector)
+  //         } else if (entry.isFile) {
+  //           const document = await this.langiumDocuments.getOrCreateDocument(entry.uri)
+  //           collector(document)
+  //         }
+  //       }
+  //     } catch (error) {
+  //       logError(error)
+  //     }
+  //   }
+  // }
   /**
-   * We override the default implementation to process project config files during the traversal.
-   * This is necessary to ensure that the project config files are loaded and processed correctly.
+   * Determine whether the given folder entry shall be included while indexing the workspace.
    */
-  async traverseFolder(workspaceFolder, folderPath, fileExtensions, collector) {
-    const content = await this.fileSystemProvider.readDirectory(folderPath);
-    await Promise.all(content.map(async (entry) => {
-      if (await this.projects.loadConfigFile(entry)) {
-        return;
-      }
-      if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {
-        if (entry.isDirectory) {
-          await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector);
-        } else if (entry.isFile) {
-          const document = await this.langiumDocuments.getOrCreateDocument(entry.uri);
-          collector(document);
-        }
-      }
-    }));
+  includeEntry(_workspaceFolder, entry, fileExtensions) {
+    if (this.services.workspace.ProjectsManager.isConfigFile(entry)) {
+      return false;
+    }
+    if (entry.isFile) {
+      return !this.services.workspace.ProjectsManager.checkIfExcluded(entry.uri);
+    }
+    return super.includeEntry(_workspaceFolder, entry, fileExtensions);
   }
   workspace() {
     if (this.folders && hasAtLeast(this.folders, 1)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.27.3",
+  "version": "1.28.1",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -96,7 +96,8 @@
   "devDependencies": {
     "@msgpack/msgpack": "^3.1.1",
     "@smithy/util-base64": "^4.0.0",
-    "@types/node": "^20.17.28",
+    "@types/node": "^20.17.30",
+    "@types/picomatch": "^4.0.0",
     "@types/which": "^3.0.4",
     "esm-env": "^1.2.2",
     "fast-equals": "^5.2.2",
@@ -107,26 +108,29 @@
     "langium-cli": "3.4.0",
     "natural-compare-lite": "^1.4.0",
     "p-debounce": "^4.0.0",
+    "p-queue": "^8.1.0",
+    "picomatch": "^4.0.2",
+    "p-timeout": "^6.1.4",
     "pretty-ms": "^9.2.0",
     "remeda": "^2.21.2",
     "strip-indent": "^4.0.0",
     "tsx": "~4.19.3",
-    "turbo": "^2.4.4",
-    "type-fest": "^4.38.0",
-    "typescript": "^5.8.2",
-    "ufo": "^1.5.4",
+    "turbo": "^2.5.0",
+    "type-fest": "^4.39.1",
+    "typescript": "^5.8.3",
+    "ufo": "^1.6.1",
     "unbuild": "^3.5.0",
     "valibot": "^1.0.0",
-    "vitest": "^3.0.9",
+    "vitest": "^3.1.1",
     "vscode-languageserver": "9.0.1",
-    "vscode-languageserver-types": "3.17.5",
     "vscode-languageserver-protocol": "3.17.5",
+    "vscode-languageserver-types": "3.17.5",
     "which": "^5.0.0",
-    "@likec4/core": "1.27.3",
-    "@likec4/icons": "1.27.3",
-    "@likec4/layouts": "1.27.3",
-    "@likec4/log": "1.27.3",
-    "@likec4/tsconfig": "1.27.3"
+    "@likec4/core": "1.28.1",
+    "@likec4/layouts": "1.28.1",
+    "@likec4/tsconfig": "1.28.1",
+    "@likec4/log": "1.28.1",
+    "@likec4/icons": "1.28.1"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

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

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

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

@@ -1,17 +0,0 @@
-import { ast, elementExpressionFromPredicate } from "../ast.js";
-import { tryOrLog } from "./_shared.js";
-export const dynamicViewRulePredicate = (_services) => {
-  return tryOrLog((predicate, accept) => {
-    const expr = elementExpressionFromPredicate(predicate.value);
-    switch (true) {
-      case ast.isElementKindExpression(expr):
-      case ast.isElementTagExpression(expr):
-      case ast.isWildcardExpression(expr): {
-        accept("warning", `Predicate is ignored, as not supported in dynamic views`, {
-          node: predicate
-        });
-        return;
-      }
-    }
-  });
-};