@likec4/language-server 1.25.1 → 1.26.0

package/dist/test/testServices.d.ts

@@ -14,11 +14,25 @@ export declare function createTestServices(workspace?: string): {
         errors: any;
         warnings: any;
     }>;
-    buildModel: () => Promise<ComputedLikeC4Model>;
+    buildModel: () => Promise<ComputedLikeC4ModelData>;
     buildLikeC4Model: () => Promise<any>;
     resetState: () => Promise<void>;
     format: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<any>;
 };
+export declare function createMultiProjectTestServices<const Projects extends Record<string, Record<string, string>>>(data: Projects): Promise<{
+    projects: { readonly [K in keyof Projects]: { readonly [L in keyof Projects[K]]: LikeC4LangiumDocument; }; };
+    /**
+     * Add document outside of projects
+     */
+    addDocumentOutside: (input: string) => Promise<LikeC4LangiumDocument>;
+    validateAll: () => Promise<{
+        diagnostics: any;
+        errors: any;
+        warnings: any;
+    }>;
+    buildModel: (projectId: keyof Projects) => Promise<ComputedLikeC4ModelData>;
+    buildLikeC4Model: (projectId: keyof Projects) => Promise<any>;
+}>;
 export type TestServices = ReturnType<typeof createTestServices>;
 export type TestParseFn = TestServices['validate'];
 export type TestValidateFn = TestServices['validate'];

package/dist/test/testServices.js

@@ -1,5 +1,6 @@
-import { DocumentState, EmptyFileSystem, TextDocument } from "langium";
+import { DocumentState, EmptyFileSystem, TextDocument, UriUtils } from "langium";
 import * as assert from "node:assert";
+import { entries } from "remeda";
 import stripIndent from "strip-indent";
 import { DiagnosticSeverity } from "vscode-languageserver-types";
 import { URI, Utils } from "vscode-uri";
@@ -18,19 +19,21 @@ export function createTestServices(workspace = "file:///test/workspace") {
   };
   let isInitialized = false;
   let documentIndex = 1;
-  const addDocument = async (input, uri) => {
-    if (!isInitialized) {
-      isInitialized = true;
-      await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-        services.shared.workspace.WorkspaceManager.initialize({
-          capabilities: {},
-          processId: null,
-          rootUri: null,
-          workspaceFolders: [workspaceFolder]
-        });
-        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+  async function initialize() {
+    if (isInitialized) return;
+    isInitialized = true;
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      services.shared.workspace.WorkspaceManager.initialize({
+        capabilities: {},
+        processId: null,
+        rootUri: workspaceFolder.uri,
+        workspaceFolders: [workspaceFolder]
       });
-    }
+      await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+    });
+  }
+  const addDocument = async (input, uri) => {
+    await initialize();
     const docUri = Utils.resolvePath(
       workspaceUri,
       "./src/",
@@ -82,9 +85,7 @@ export function createTestServices(workspace = "file:///test/workspace") {
   const validateAll = async () => {
     const docs = langiumDocuments.all.toArray();
     assert.ok(docs.length > 0, "no documents to validate");
-    await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
-      await documentBuilder.build(docs, { validation: true }, cancelToken);
-    });
+    await documentBuilder.build(docs, { validation: true });
     const diagnostics = docs.flatMap((doc) => doc.diagnostics ?? []);
     const warnings = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Warning ? d.message : []);
     const errors = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Error ? d.message : []);
@@ -112,7 +113,7 @@ export function createTestServices(workspace = "file:///test/workspace") {
   };
   const resetState = async () => {
     await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
-      const docs = langiumDocuments.all.toArray().map((doc) => doc.uri);
+      const docs = langiumDocuments.allExcludingBuiltin.toArray().map((doc) => doc.uri);
       await documentBuilder.update([], docs, cancelToken);
     });
   };
@@ -128,3 +129,50 @@ export function createTestServices(workspace = "file:///test/workspace") {
     format
   };
 }
+export async function createMultiProjectTestServices(data) {
+  const workspace = "file:///test/workspace";
+  const {
+    services,
+    addDocument,
+    validateAll
+  } = createTestServices(workspace);
+  const projects = {};
+  for (const [name, files] of entries(data)) {
+    const folderUri = UriUtils.joinPath(URI.parse(workspace), "src", name);
+    services.shared.workspace.ProjectsManager.registerProject({
+      config: {
+        name
+      },
+      folderUri
+    });
+    projects[name] = {};
+    for (let [docName, content] of entries(files)) {
+      const fileName = docName.endsWith(".c4") ? docName : `${docName}.c4`;
+      projects[name][docName] = await addDocument(content, `${name}/${fileName}`);
+    }
+  }
+  async function buildLikeC4Model(projectId) {
+    if (services.shared.workspace.LangiumDocuments.all.some((doc) => doc.state < DocumentState.Validated)) {
+      await validateAll();
+    }
+    const likec4model = await services.likec4.ModelBuilder.buildLikeC4Model(projectId);
+    if (!likec4model) throw new Error("No model found");
+    return likec4model;
+  }
+  async function buildModel(projectId) {
+    const model = await buildLikeC4Model(projectId);
+    return model.$model;
+  }
+  return {
+    projects,
+    /**
+     * Add document outside of projects
+     */
+    addDocumentOutside: async (input) => {
+      return await addDocument(input);
+    },
+    validateAll,
+    buildModel,
+    buildLikeC4Model
+  };
+}

package/dist/utils/index.d.ts

@@ -1,2 +1,5 @@
 export * from './disposable';
+export * from './elementRef';
+export * from './fqnRef';
+export * from './projectId';
 export * from './stringHash';

package/dist/utils/index.js

@@ -1,2 +1,5 @@
 export * from "./disposable.js";
+export * from "./elementRef.js";
+export * from "./fqnRef.js";
+export * from "./projectId.js";
 export * from "./stringHash.js";

package/dist/utils/projectId.d.ts

@@ -0,0 +1,3 @@
+import { type ProjectId } from '@likec4/core';
+import { type AstNode, type LangiumDocument } from 'langium';
+export declare function projectIdFrom(value: AstNode | LangiumDocument): ProjectId;

package/dist/utils/projectId.js

@@ -0,0 +1,6 @@
+import { nonNullable } from "@likec4/core";
+import { AstUtils, isAstNode } from "langium";
+export function projectIdFrom(value) {
+  const doc = isAstNode(value) ? AstUtils.getDocument(value) : value;
+  return nonNullable(doc.likec4ProjectId, () => `Invalid state, document ${doc.uri} has no project ID assigned`);
+}

package/dist/validation/deployment-checks.js

@@ -1,6 +1,7 @@
 import { FqnRef, isSameHierarchy, nonNullable } from "@likec4/core";
 import { AstUtils } from "langium";
 import { ast } from "../ast.js";
+import { projectIdFrom } from "../utils/index.js";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
 const { getDocument } = AstUtils;
 export const deploymentNodeChecks = (services) => {
@@ -21,8 +22,9 @@ export const deploymentNodeChecks = (services) => {
         range
       });
     }
+    const projectId = projectIdFrom(el);
     const fqnName = DeploymentsIndex.getFqn(el);
-    const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray();
+    const withSameName = DeploymentsIndex.byFqn(projectId, fqnName).limit(2).toArray();
     if (withSameName.length > 1) {
       accept(
         "error",
@@ -53,8 +55,9 @@ export const deployedInstanceChecks = (services) => {
         range
       });
     }
+    const projectId = projectIdFrom(el);
     const fqnName = DeploymentsIndex.getFqn(el);
-    const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray();
+    const withSameName = DeploymentsIndex.byFqn(projectId, fqnName).limit(2).toArray();
     if (withSameName.length > 1) {
       accept(
         "error",

package/dist/validation/element.js

@@ -1,4 +1,5 @@
 import { AstUtils } from "langium";
+import { projectIdFrom } from "../utils/index.js";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
 const { getDocument } = AstUtils;
 export const elementChecks = (services) => {
@@ -22,7 +23,7 @@ export const elementChecks = (services) => {
     const doc = getDocument(el);
     const docUri = doc.uri;
     const elPath = locator.getAstNodePath(el);
-    const withSameFqn = fqnIndex.byFqn(fqn).filter((v) => v.documentUri !== docUri || v.path !== elPath).head();
+    const withSameFqn = fqnIndex.byFqn(projectIdFrom(doc), fqn).filter((v) => v.documentUri !== docUri || v.path !== elPath).head();
     if (withSameFqn) {
       const isAnotherDoc = withSameFqn.documentUri !== docUri;
       accept(

package/dist/validation/specification.js

@@ -1,5 +1,6 @@
 import { AstUtils } from "langium";
 import { ast } from "../ast.js";
+import { projectIdFrom } from "../utils/index.js";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
 export const specificationRuleChecks = (_) => {
   return tryOrLog((node, accept) => {
@@ -40,7 +41,8 @@ export const elementKindChecks = (services) => {
         property: "name"
       });
     }
-    const sameKind = index.allElements(ast.ElementKind).filter((n) => n.name === node.name && n.node !== node).head();
+    const projectId = projectIdFrom(node);
+    const sameKind = index.projectElements(projectId, ast.ElementKind).filter((n) => n.name === node.name && n.node !== node).head();
     if (sameKind) {
       const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri;
       accept("error", `Duplicate element kind '${node.name}'`, {
@@ -70,7 +72,8 @@ export const deploymentNodeKindChecks = (services) => {
         property: "name"
       });
     }
-    const sameKind = index.allElements(ast.DeploymentNodeKind).filter((n) => n.name === node.name && n.node !== node).head();
+    const projectId = projectIdFrom(node);
+    const sameKind = index.projectElements(projectId, ast.DeploymentNodeKind).filter((n) => n.name === node.name && n.node !== node).head();
     if (sameKind) {
       const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri;
       accept("error", `Duplicate deploymentNode kind '${node.name}'`, {
@@ -95,7 +98,8 @@ export const tagChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
     const tagname = "#" + node.name;
-    const sameTag = index.allElements(ast.Tag).filter((n) => n.name === tagname && n.node !== node).head();
+    const projectId = projectIdFrom(node);
+    const sameTag = index.projectElements(projectId, ast.Tag).filter((n) => n.name === tagname && n.node !== node).head();
     if (sameTag) {
       const isAnotherDoc = sameTag.documentUri !== AstUtils.getDocument(node).uri;
       accept(
@@ -129,7 +133,8 @@ export const relationshipChecks = (services) => {
         property: "name"
       });
     }
-    const sameKinds = index.allElements(ast.RelationshipKind).filter((n) => n.name === node.name).limit(2).count();
+    const projectId = projectIdFrom(node);
+    const sameKinds = index.projectElements(projectId, ast.RelationshipKind).filter((n) => n.name === node.name).limit(2).count();
     if (sameKinds > 1) {
       accept("error", `Duplicate RelationshipKind '${node.name}'`, {
         node,
@@ -141,8 +146,9 @@ export const relationshipChecks = (services) => {
 export const globalPredicateChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
-    const predicateGroups = index.allElements(ast.GlobalPredicateGroup);
-    const dynamicPredicateGroups = index.allElements(ast.GlobalDynamicPredicateGroup);
+    const projectId = projectIdFrom(node);
+    const predicateGroups = index.projectElements(projectId, ast.GlobalPredicateGroup);
+    const dynamicPredicateGroups = index.projectElements(projectId, ast.GlobalDynamicPredicateGroup);
     const sameName = predicateGroups.concat(dynamicPredicateGroups).filter((s) => s.name === node.name).limit(2).count();
     if (sameName > 1) {
       accept("error", `Duplicate GlobalPredicateGroup or GlobalDynamicPredicateGroup name '${node.name}'`, {
@@ -155,7 +161,8 @@ export const globalPredicateChecks = (services) => {
 export const globalStyleIdChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
-    const sameName = index.allElements(ast.GlobalStyleId).filter((s) => s.name === node.name).limit(2).count();
+    const projectId = projectIdFrom(node);
+    const sameName = index.projectElements(projectId, ast.GlobalStyleId).filter((s) => s.name === node.name).limit(2).count();
     if (sameName > 1) {
       accept("error", `Duplicate GlobalStyleId name '${node.name}'`, {
         node,

package/dist/validation/view.js

@@ -1,21 +1,23 @@
 import { ast } from "../ast.js";
+import { projectIdFrom } from "../utils/index.js";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
 export const viewChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
-  return tryOrLog((el, accept) => {
-    if (!el.name) {
+  return tryOrLog((node, accept) => {
+    if (!node.name) {
       return;
     }
-    if (RESERVED_WORDS.includes(el.name)) {
-      accept("error", `Reserved word: ${el.name}`, {
-        node: el,
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept("error", `Reserved word: ${node.name}`, {
+        node,
         property: "name"
       });
     }
-    const anotherViews = index.allElements(ast.LikeC4View).filter((n) => n.name === el.name).limit(2).count();
+    const projectId = projectIdFrom(node);
+    const anotherViews = index.projectElements(projectId, ast.LikeC4View).filter((n) => n.name === node.name).limit(2).count();
     if (anotherViews > 1) {
-      accept("error", `Duplicate view '${el.name}'`, {
-        node: el,
+      accept("error", `Duplicate view '${node.name}'`, {
+        node,
         property: "name"
       });
     }

package/dist/views/index.d.ts

@@ -1 +1 @@
-export { LikeC4Views } from './likec4-views';
+export { DefaultLikeC4Views, type LikeC4Views } from './likec4-views';

package/dist/views/index.js

@@ -1 +1 @@
-export { LikeC4Views } from "./likec4-views.js";
+export { DefaultLikeC4Views } from "./likec4-views.js";

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

@@ -1,6 +1,6 @@
-import type { ComputedView, DiagramView, OverviewGraph, ViewId } from '@likec4/core';
+import type { ComputedView, DiagramView, OverviewGraph, ProjectId, ViewId } from '@likec4/core';
 import { GraphvizLayouter } from '@likec4/layouts';
-import { type Cancellation } from 'langium';
+import { CancellationToken } from 'vscode-jsonrpc';
 import type { LikeC4Services } from '../module';
 export type GraphvizOut = {
     dot: string;
@@ -11,18 +11,27 @@ type GraphvizSvgOut = {
     dot: string;
     svg: string;
 };
-export declare class LikeC4Views {
+export interface LikeC4Views {
+    readonly layouter: GraphvizLayouter;
+    computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
+    layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<Readonly<GraphvizOut>>>;
+    layoutView(viewId: ViewId, projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut | null>;
+    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
+    viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
+    overviewGraph(): Promise<OverviewGraph>;
+}
+export declare class DefaultLikeC4Views implements LikeC4Views {
     private services;
     private cache;
     private viewsWithReportedErrors;
     private ModelBuilder;
     constructor(services: LikeC4Services);
     get layouter(): GraphvizLayouter;
-    computedViews(cancelToken?: Cancellation.CancellationToken): Promise<ComputedView[]>;
-    layoutAllViews(cancelToken?: Cancellation.CancellationToken): Promise<Array<Readonly<GraphvizOut>>>;
-    layoutView(viewId: ViewId, cancelToken?: Cancellation.CancellationToken): Promise<GraphvizOut | null>;
-    diagrams(): Promise<Array<DiagramView>>;
-    viewsAsGraphvizOut(): Promise<Array<GraphvizSvgOut>>;
+    computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
+    layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<Readonly<GraphvizOut>>>;
+    layoutView(viewId: ViewId, projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut | null>;
+    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
+    viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
     overviewGraph(): Promise<OverviewGraph>;
 }
 export {};

package/dist/views/likec4-views.js

@@ -1,9 +1,10 @@
 import { loggable } from "@likec4/log";
 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 LikeC4Views {
+export class DefaultLikeC4Views {
   constructor(services) {
     this.services = services;
     this.ModelBuilder = services.likec4.ModelBuilder;
@@ -14,12 +15,12 @@ export class LikeC4Views {
   get layouter() {
     return this.services.likec4.Layouter;
   }
-  async computedViews(cancelToken) {
-    const likeC4Model = await this.ModelBuilder.buildLikeC4Model(cancelToken);
+  async computedViews(projectId, cancelToken = CancellationToken.None) {
+    const likeC4Model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
     return values(likeC4Model.$model.views);
   }
-  async layoutAllViews(cancelToken) {
-    const views = await this.computedViews(cancelToken);
+  async layoutAllViews(projectId, cancelToken = CancellationToken.None) {
+    const views = await this.computedViews(projectId, cancelToken);
     if (views.length === 0) {
       return [];
     }
@@ -52,8 +53,8 @@ export class LikeC4Views {
     }
     return results;
   }
-  async layoutView(viewId, cancelToken) {
-    const model = await this.ModelBuilder.buildLikeC4Model(cancelToken);
+  async layoutView(viewId, projectId, cancelToken = CancellationToken.None) {
+    const model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
     const view = model.findView(viewId)?.$view;
     if (!view) {
       logger.warn`layoutView ${viewId} not found`;
@@ -81,17 +82,17 @@ export class LikeC4Views {
       return Promise.reject(e);
     }
   }
-  async diagrams() {
-    const layouted = await this.layoutAllViews();
+  async diagrams(projectId, cancelToken = CancellationToken.None) {
+    const layouted = await this.layoutAllViews(projectId, cancelToken);
     return layouted.map((l) => l.diagram);
   }
-  async viewsAsGraphvizOut() {
+  async viewsAsGraphvizOut(projectId, cancelToken = CancellationToken.None) {
     const KEY = "All-LayoutedViews-DotWithSvg";
     const cache = this.services.ValidatedWorkspaceCache;
     if (cache.has(KEY)) {
       return await Promise.resolve(cache.get(KEY));
     }
-    const views = await this.computedViews();
+    const views = await this.computedViews(projectId, cancelToken);
     const tasks = views.map(async (view) => {
       const { dot, svg } = await this.layouter.svg(view);
       return {

package/dist/workspace/AstNodeDescriptionProvider.d.ts

@@ -0,0 +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;
+    constructor(services: LikeC4Services);
+    createDescription(node: AstNode, name: string | undefined, document?: LangiumDocument): AstNodeDescription;
+}

package/dist/workspace/AstNodeDescriptionProvider.js

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

package/dist/workspace/IndexManager.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectId } from '@likec4/core';
+import { type AstNodeDescription, type LangiumDocument, type Stream, DefaultIndexManager } from 'langium';
+import { CancellationToken } from 'vscode-jsonrpc';
+import type { LikeC4SharedServices } from '../module';
+export declare class IndexManager extends DefaultIndexManager {
+    private projects;
+    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

@@ -0,0 +1,17 @@
+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;
+  }
+  async updateContent(document, cancelToken = CancellationToken.None) {
+    document.likec4ProjectId = this.projects.belongsTo(document.uri);
+    await super.updateContent(document, cancelToken);
+  }
+  projectElements(projectId, nodeType, uris) {
+    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));
+  }
+}

package/dist/workspace/LangiumDocuments.d.ts

@@ -0,0 +1,14 @@
+import type { NonEmptyArray, ProjectId } from '@likec4/core';
+import { type Stream, DefaultLangiumDocuments } from 'langium';
+import { type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4SharedServices } from '../module';
+export declare class LangiumDocuments extends DefaultLangiumDocuments {
+    private projects;
+    constructor(services: LikeC4SharedServices);
+    /**
+     * Returns all user documents, excluding built-in documents.
+     */
+    get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
+    projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
+    groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+}

package/dist/workspace/LangiumDocuments.js

@@ -0,0 +1,31 @@
+import { DefaultLangiumDocuments } from "langium";
+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;
+  }
+  /**
+   * Returns all user documents, excluding built-in documents.
+   */
+  get allExcludingBuiltin() {
+    return super.all.filter((doc) => {
+      if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
+        return false;
+      }
+      if (!doc.likec4ProjectId) {
+        doc.likec4ProjectId = this.projects.belongsTo(doc.uri);
+      }
+      return true;
+    });
+  }
+  projectDocuments(projectId) {
+    return this.allExcludingBuiltin.filter((doc) => doc.likec4ProjectId === projectId);
+  }
+  groupedByProject() {
+    return groupBy(this.allExcludingBuiltin.toArray(), prop("likec4ProjectId"));
+  }
+}

package/dist/workspace/ProjectsManager.d.ts

@@ -0,0 +1,48 @@
+import type { NonEmptyReadonlyArray, ProjectId } from '@likec4/core';
+import { type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import { ProjectConfig } from '../config';
+import type { LikeC4SharedServices } from '../module';
+export declare class ProjectsManager {
+    protected services: LikeC4SharedServices;
+    /**
+     * The global project ID used for all documents
+     * that are not part of a specific project.
+     */
+    static readonly DefaultProjectId: ProjectId;
+    static readonly ConfigFileNames: string[];
+    /**
+     * 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;
+    constructor(services: LikeC4SharedServices);
+    get defaultProjectId(): ProjectId | undefined;
+    get all(): NonEmptyReadonlyArray<ProjectId>;
+    getProject(projectId: ProjectId): {
+        folder: URI;
+        config: Readonly<ProjectConfig>;
+    };
+    ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
+    hasMultipleProjects(): 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>;
+    registerProject(opts: {
+        config: ProjectConfig;
+        folderUri: URI | string;
+    }): Promise<void>;
+    belongsTo(document: LangiumDocument | URI | string): ProjectId;
+    private getProjectId;
+    protected get mappingsToProject(): WorkspaceCache<string, ProjectId>;
+}