@likec4/language-server 1.24.0 → 1.25.0

package/dist/lsp/CodeLensProvider.js

@@ -1,4 +1,4 @@
-import { DocumentState, interruptAndCheck } from "langium";
+import { DocumentState } from "langium";
 import { isLikeC4LangiumDocument, ViewOps } from "../ast.js";
 import { logger } from "../logger.js";
 export class LikeC4CodeLensProvider {
@@ -9,13 +9,10 @@ export class LikeC4CodeLensProvider {
     if (!isLikeC4LangiumDocument(doc)) {
       return;
     }
-    if (doc.state !== DocumentState.Validated) {
-      logger.debug(`Waiting for document ${doc.uri.path} to be validated`);
-      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
-      logger.debug(`Document ${doc.uri.path} is validated`);
-    }
-    if (cancelToken) {
-      await interruptAndCheck(cancelToken);
+    if (doc.state <= DocumentState.Linked) {
+      logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
+      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
+      logger.debug(`Document is linked`);
     }
     const views = doc.parseResult.value.views.flatMap((v) => v.views);
     return views.flatMap((ast) => {

package/dist/lsp/DocumentLinkProvider.js

@@ -1,8 +1,7 @@
-import { AstUtils, DocumentState, GrammarUtils, interruptAndCheck } from "langium";
+import { AstUtils, GrammarUtils } from "langium";
 import { hasLeadingSlash, hasProtocol, isRelative, withoutBase, withoutLeadingSlash } from "ufo";
 import { ast, isLikeC4LangiumDocument } from "../ast.js";
-import { logger, logWarnError } from "../logger.js";
-const log = logger.getChild("DocumentLinkProvider");
+import { logWarnError } from "../logger.js";
 export class LikeC4DocumentLinkProvider {
   constructor(services) {
     this.services = services;
@@ -11,19 +10,11 @@ export class LikeC4DocumentLinkProvider {
     if (!isLikeC4LangiumDocument(doc)) {
       return [];
     }
-    if (doc.state !== DocumentState.Validated) {
-      log.debug(`Waiting for document ${doc.uri.path} to be validated`);
-      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
-      log.debug(`Document ${doc.uri.path} is validated`);
-    }
-    if (cancelToken) {
-      await interruptAndCheck(cancelToken);
-    }
     return AstUtils.streamAllContents(doc.parseResult.value).filter(ast.isLinkProperty).map((n) => {
       try {
         const range = GrammarUtils.findNodeForProperty(n.$cstNode, "value")?.range;
-        const target = this.resolveLink(doc, n.value);
-        if (range && hasProtocol(target)) {
+        const target = range && this.resolveLink(doc, n.value);
+        if (target && hasProtocol(target)) {
           return {
             range,
             target

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -1,7 +1,8 @@
-import { type AstNode, type MaybePromise } from 'langium';
+import { type AstNode, type LangiumDocument } from 'langium';
 import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp';
+import type { CancellationToken, DocumentSymbolParams } from 'vscode-languageserver';
 import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types';
-import { type LikeC4LangiumDocument, ast } from '../ast';
+import { ast } from '../ast';
 import type { LikeC4ModelLocator, LikeC4ModelParser } from '../model';
 import type { LikeC4Services } from '../module';
 import type { LikeC4NameProvider } from '../references';
@@ -12,7 +13,7 @@ export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvi
     protected readonly parser: LikeC4ModelParser;
     protected readonly locator: LikeC4ModelLocator;
     constructor(services: LikeC4Services);
-    getSymbols({ parseResult: { value: { specifications, models, deployments, views, likec4lib }, }, }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]>;
+    getSymbols(doc: LangiumDocument, _params: DocumentSymbolParams, cancelToken?: CancellationToken): Promise<DocumentSymbol[]>;
     protected getLikec4LibSymbol(astLib: ast.LikeC4Lib): DocumentSymbol[];
     protected getSpecSymbol(astSpec: ast.SpecificationRule): DocumentSymbol[];
     protected getModelSymbol(astModel: ast.Model): DocumentSymbol[];

package/dist/lsp/DocumentSymbolProvider.js

@@ -1,10 +1,11 @@
 import { nonexhaustive } from "@likec4/core";
-import { AstUtils, GrammarUtils } from "langium";
+import { AstUtils, DocumentState, GrammarUtils } from "langium";
 import { filter, isEmpty, isTruthy, map, pipe } from "remeda";
 import { SymbolKind } from "vscode-languageserver-types";
-import { ast } from "../ast.js";
-import { logWarnError } from "../logger.js";
+import { ast, isLikeC4LangiumDocument } from "../ast.js";
+import { logger as rootLogger, logWarnError } from "../logger.js";
 import { readStrictFqn } from "../utils/elementRef.js";
+const logger = rootLogger.getChild("DocumentSymbolProvider");
 export class LikeC4DocumentSymbolProvider {
   constructor(services) {
     this.services = services;
@@ -17,11 +18,20 @@ export class LikeC4DocumentSymbolProvider {
   nameProvider;
   parser;
   locator;
-  getSymbols({
-    parseResult: {
-      value: { specifications, models, deployments, views, likec4lib }
+  async getSymbols(doc, _params, cancelToken) {
+    if (!isLikeC4LangiumDocument(doc)) {
+      return [];
     }
-  }) {
+    if (doc.state <= DocumentState.Linked) {
+      logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
+      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
+      logger.debug(`document is Linked`);
+    }
+    const {
+      parseResult: {
+        value: { specifications, models, deployments, views, likec4lib }
+      }
+    } = doc;
     return [
       ...likec4lib.map((l) => () => this.getLikec4LibSymbol(l)),
       ...specifications.map((s) => () => this.getSpecSymbol(s)),

package/dist/model/deployments-index.d.ts

@@ -1,11 +1,10 @@
-import { type LikeC4LangiumDocument } from '../ast';
+import { type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 import type { LikeC4NameProvider } from '../references';
 import { DocumentFqnIndex, FqnIndex } from './fqn-index';
-export declare class DeploymentsIndex extends FqnIndex {
+export declare class DeploymentsIndex extends FqnIndex<ast.DeploymentElement> {
     protected services: LikeC4Services;
     protected Names: LikeC4NameProvider;
-    protected cachePrefix: string;
     constructor(services: LikeC4Services);
     protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
 }

package/dist/model/deployments-index.js

@@ -1,5 +1,5 @@
 import { ancestorsFqn, AsFqn } from "@likec4/core";
-import { MultiMap } from "langium";
+import { MultiMap } from "@likec4/core/utils";
 import { isDefined, isTruthy } from "remeda";
 import {
   ast,
@@ -10,12 +10,11 @@ import { readStrictFqn } from "../utils/elementRef.js";
 import { DocumentFqnIndex, FqnIndex } from "./fqn-index.js";
 export class DeploymentsIndex extends FqnIndex {
   constructor(services) {
-    super(services);
+    super(services, "deployments-index");
     this.services = services;
     this.Names = services.references.NameProvider;
   }
   Names;
-  cachePrefix = "deployments-index";
   createDocumentIndex(document) {
     const rootNodes = document.parseResult.value.deployments.flatMap((m) => m.elements);
     if (rootNodes.length === 0) {
@@ -33,7 +32,7 @@ export class DeploymentsIndex extends FqnIndex {
         id: fqn
       };
       ElementOps.writeId(node, fqn);
-      byfqn.add(fqn, desc);
+      byfqn.set(fqn, desc);
       return desc;
     };
     const traverseNode = (node, parentFqn) => {
@@ -50,7 +49,7 @@ export class DeploymentsIndex extends FqnIndex {
         if (!parentFqn) {
           root.push(desc);
         } else {
-          children.add(parentFqn, desc);
+          children.set(parentFqn, desc);
         }
         if (ast.isDeployedInstance(node)) {
           return [];
@@ -68,18 +67,21 @@ export class DeploymentsIndex extends FqnIndex {
           }
         }
       }
-      const directChildren = children.get(thisFqn);
       _nested = [
-        ...directChildren,
+        ...children.get(thisFqn) ?? [],
         ..._nested
       ];
-      descendants.addAll(thisFqn, _nested);
+      for (const child of _nested) {
+        descendants.set(thisFqn, child);
+      }
       if (ast.isExtendDeployment(node)) {
-        ancestorsFqn(thisFqn).forEach((ancestor) => {
-          descendants.addAll(ancestor, _nested);
-        });
+        for (const ancestor of ancestorsFqn(thisFqn)) {
+          for (const child of _nested) {
+            descendants.set(ancestor, child);
+          }
+        }
       }
-      return descendants.get(thisFqn);
+      return descendants.get(thisFqn) ?? [];
     };
     for (const node of rootNodes) {
       try {

package/dist/model/fqn-index.d.ts

@@ -1,18 +1,19 @@
 import { type Fqn } from '@likec4/core/types';
-import { DefaultWeakMap } from '@likec4/core/utils';
-import { type LangiumDocuments, type Stream, MultiMap } from 'langium';
+import { DefaultWeakMap, MultiMap } from '@likec4/core/utils';
+import { type AstNode, type LangiumDocuments, type Stream, WorkspaceCache } from 'langium';
 import { type AstNodeDescriptionWithFqn, type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 import { ADisposable } from '../utils';
-export declare class FqnIndex extends ADisposable {
+export declare class FqnIndex<AstNd extends AstNode = ast.Element> extends ADisposable {
     protected services: LikeC4Services;
+    private cachePrefix;
     protected langiumDocuments: LangiumDocuments;
     protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
-    protected cachePrefix: string;
-    constructor(services: LikeC4Services);
+    protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
+    constructor(services: LikeC4Services, cachePrefix?: string);
     private documents;
     get(document: LikeC4LangiumDocument): DocumentFqnIndex;
-    getFqn(el: ast.Element | ast.DeploymentElement): Fqn;
+    getFqn(el: AstNd): Fqn;
     byFqn(fqn: Fqn): Stream<AstNodeDescriptionWithFqn>;
     directChildrenOf(parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
     /**

package/dist/model/fqn-index.js

@@ -1,11 +1,11 @@
 import { invariant, nonNullable } from "@likec4/core";
 import { AsFqn } from "@likec4/core/types";
-import { ancestorsFqn, compareNatural, DefaultWeakMap, sortNaturalByFqn } from "@likec4/core/utils";
+import { ancestorsFqn, compareNatural, DefaultWeakMap, MultiMap, sortNaturalByFqn } from "@likec4/core/utils";
 import {
   AstUtils,
   DocumentState,
-  MultiMap,
-  stream
+  stream,
+  WorkspaceCache
 } from "langium";
 import { isDefined, isEmpty, isTruthy } from "remeda";
 import {
@@ -17,11 +17,13 @@ import { logWarnError } from "../logger.js";
 import { ADisposable } from "../utils/index.js";
 import { readStrictFqn } from "../utils/elementRef.js";
 export class FqnIndex extends ADisposable {
-  constructor(services) {
+  constructor(services, cachePrefix = "fqn-index") {
     super();
     this.services = services;
+    this.cachePrefix = cachePrefix;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     this.documentCache = new DefaultWeakMap((doc) => this.createDocumentIndex(doc));
+    this.workspaceCache = new WorkspaceCache(services.shared, DocumentState.IndexedContent);
     this.onDispose(
       services.shared.workspace.DocumentBuilder.onDocumentPhase(
         DocumentState.IndexedContent,
@@ -36,7 +38,7 @@ export class FqnIndex extends ADisposable {
   }
   langiumDocuments;
   documentCache;
-  cachePrefix = "fqn-index";
+  workspaceCache;
   documents() {
     return this.langiumDocuments.all.filter(
       (d) => isLikeC4LangiumDocument(d) && d.state >= DocumentState.IndexedContent
@@ -49,53 +51,64 @@ export class FqnIndex extends ADisposable {
     return this.documentCache.get(document);
   }
   getFqn(el) {
+    invariant(ast.isElement(el) || ast.isDeploymentElement(el));
     let id = ElementOps.readId(el);
     if (isTruthy(id)) {
       return id;
     }
     const doc = AstUtils.getDocument(el);
     invariant(isLikeC4LangiumDocument(doc));
+    logWarnError(`Document ${doc.uri.path} is not indexed, but getFqn was called`);
     this.get(doc);
     return nonNullable(ElementOps.readId(el), "Element fqn must be set, invalid state");
   }
   byFqn(fqn) {
-    return this.documents().flatMap((doc) => {
-      return this.get(doc).byFqn(fqn);
-    });
+    return stream(this.workspaceCache.get(`${this.cachePrefix}:${fqn}`, () => {
+      return this.documents().toArray().flatMap((doc) => {
+        return this.get(doc).byFqn(fqn);
+      });
+    }));
   }
   directChildrenOf(parent) {
     return stream(
-      this.documents().reduce((map, doc) => {
-        this.get(doc).children(parent).forEach((desc) => {
-          map.add(desc.name, desc);
-        });
-        return map;
-      }, new MultiMap()).entriesGroupedByKey().flatMap(([_name, descs]) => descs.length === 1 ? descs : []).toArray().sort((a, b) => compareNatural(a.name, b.name))
+      this.workspaceCache.get(`${this.cachePrefix}:directChildrenOf:${parent}`, () => {
+        const allchildren = this.documents().reduce((map, doc) => {
+          this.get(doc).children(parent).forEach((desc) => {
+            map.set(desc.name, desc);
+          });
+          return map;
+        }, new MultiMap());
+        return uniqueByName(allchildren).sort((a, b) => compareNatural(a.name, b.name));
+      })
     );
   }
   /**
    * Returns descedant elements with unique names in the scope
    */
   uniqueDescedants(parent) {
-    const { children, descendants } = this.documents().reduce((map, doc) => {
-      const docIndex = this.get(doc);
-      docIndex.children(parent).forEach((desc) => {
-        map.children.add(desc.name, desc);
-      });
-      docIndex.descendants(parent).forEach((desc) => {
-        map.descendants.add(desc.name, desc);
-      });
-      return map;
-    }, {
-      children: new MultiMap(),
-      descendants: new MultiMap()
-    });
-    const uniqueChildren = children.entriesGroupedByKey().flatMap(([_name, descs]) => descs.length === 1 ? descs : []).toArray().sort((a, b) => compareNatural(a.name, b.name));
-    const uniqueDescendants = descendants.entriesGroupedByKey().flatMap(([_name, descs]) => descs.length === 1 && !children.has(_name) ? descs : []).toArray();
-    return stream([
-      ...uniqueChildren,
-      ...sortNaturalByFqn(uniqueDescendants)
-    ]);
+    return stream(
+      this.workspaceCache.get(`${this.cachePrefix}:uniqueDescedants:${parent}`, () => {
+        const { children, descendants } = this.documents().reduce((map, doc) => {
+          const docIndex = this.get(doc);
+          docIndex.children(parent).forEach((desc) => {
+            map.children.set(desc.name, desc);
+          });
+          docIndex.descendants(parent).forEach((desc) => {
+            map.descendants.set(desc.name, desc);
+          });
+          return map;
+        }, {
+          children: new MultiMap(),
+          descendants: new MultiMap()
+        });
+        const uniqueChildren = uniqueByName(children).sort((a, b) => compareNatural(a.name, b.name));
+        const uniqueDescendants = [...descendants.associations()].flatMap(([_name, descs]) => descs.length === 1 && !children.has(_name) ? descs : []);
+        return [
+          ...uniqueChildren,
+          ...sortNaturalByFqn(uniqueDescendants)
+        ];
+      })
+    );
   }
   createDocumentIndex(document) {
     const rootElements = document.parseResult.value.models.flatMap((m) => m.elements);
@@ -113,7 +126,7 @@ export class FqnIndex extends ADisposable {
         id: fqn
       };
       ElementOps.writeId(node, fqn);
-      byfqn.add(fqn, desc);
+      byfqn.set(fqn, desc);
       return desc;
     };
     const traverseNode = (el, parentFqn) => {
@@ -124,7 +137,7 @@ export class FqnIndex extends ADisposable {
         if (!parentFqn) {
           root.push(desc);
         } else {
-          children.add(parentFqn, desc);
+          children.set(parentFqn, desc);
         }
       } else {
         thisFqn = readStrictFqn(el.element);
@@ -141,18 +154,22 @@ export class FqnIndex extends ADisposable {
           }
         }
       }
-      const directChildren = children.get(thisFqn);
+      const directChildren = children.get(thisFqn) ?? [];
       _nested = [
         ...directChildren,
         ..._nested
       ];
-      descendants.addAll(thisFqn, _nested);
+      for (const child of _nested) {
+        descendants.set(thisFqn, child);
+      }
       if (ast.isExtendElement(el)) {
-        ancestorsFqn(thisFqn).forEach((ancestor) => {
-          descendants.addAll(ancestor, _nested);
-        });
+        for (const ancestor of ancestorsFqn(thisFqn)) {
+          for (const child of _nested) {
+            descendants.set(ancestor, child);
+          }
+        }
       }
-      return descendants.get(thisFqn);
+      return descendants.get(thisFqn) ?? [];
     };
     for (const node of rootElements) {
       try {
@@ -167,6 +184,9 @@ export class FqnIndex extends ADisposable {
     return new DocumentFqnIndex(root, children, descendants, byfqn);
   }
 }
+function uniqueByName(multimap) {
+  return [...multimap.associations()].flatMap(([_name, descs]) => descs.length === 1 ? descs : []);
+}
 export class DocumentFqnIndex {
   constructor(_rootElements, _children, _descendants, _byfqn) {
     this._rootElements = _rootElements;
@@ -179,12 +199,12 @@ export class DocumentFqnIndex {
     return this._rootElements;
   }
   byFqn(fqn) {
-    return this._byfqn.get(fqn);
+    return this._byfqn.get(fqn) ?? [];
   }
   children(parent) {
-    return this._children.get(parent);
+    return this._children.get(parent) ?? [];
   }
   descendants(nodeName) {
-    return this._descendants.get(nodeName);
+    return this._descendants.get(nodeName) ?? [];
   }
 }

package/dist/model/model-builder.d.ts

@@ -4,15 +4,12 @@ import { type Cancellation, type URI, Disposable } from 'langium';
 import type { LikeC4Services } from '../module';
 import { ADisposable } from '../utils';
 type ModelParsedListener = (docs: URI[]) => void;
-type ParseModelResult = {
-    model: c4.ParsedLikeC4Model;
-    computeView: (view: c4.LikeC4View) => c4.ComputeViewResult;
-};
 export declare class LikeC4ModelBuilder extends ADisposable {
     private parser;
     private listeners;
     private cache;
     private DocumentBuilder;
+    private LangiumDocuments;
     constructor(services: LikeC4Services);
     /**
      * WARNING:
@@ -20,7 +17,7 @@ export declare class LikeC4ModelBuilder extends ADisposable {
      * Otherwise, the model may be incomplete.
      */
     private unsafeSyncParseModel;
-    parseModel(cancelToken?: Cancellation.CancellationToken): Promise<ParseModelResult | null>;
+    parseModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ParsedLikeC4Model | null>;
     private previousViews;
     /**
      * WARNING:

package/dist/model/model-builder.js

@@ -8,30 +8,36 @@ import {
   Disposable,
   DocumentState
 } from "langium";
+import prettyMs from "pretty-ms";
 import {
   filter,
   groupBy,
+  isNot,
   mapToObj,
   pipe,
+  prop,
   values
 } from "remeda";
+import { isLikeC4Builtin } from "../likec4lib.js";
 import { logger as mainLogger, logWarnError } from "../logger.js";
 import { ADisposable } from "../utils/index.js";
 import { assignNavigateTo } from "../view-utils/index.js";
 import { buildModel } from "./builder/buildModel.js";
 const CACHE_KEY_PARSED_MODEL = "ParsedLikeC4Model";
 const CACHE_KEY_COMPUTED_MODEL = "ComputedLikeC4Model";
-const logger = mainLogger.getChild("model-builder");
+const logger = mainLogger.getChild("ModelBuilder");
 export class LikeC4ModelBuilder extends ADisposable {
   parser;
   listeners = [];
   cache;
   DocumentBuilder;
+  LangiumDocuments;
   constructor(services) {
     super();
     this.parser = services.likec4.ModelParser;
     this.cache = services.ValidatedWorkspaceCache;
     this.DocumentBuilder = services.shared.workspace.DocumentBuilder;
+    this.LangiumDocuments = services.shared.workspace.LangiumDocuments;
     this.onDispose(
       this.DocumentBuilder.onUpdate((_changed, deleted) => {
         if (deleted.length > 0) {
@@ -43,8 +49,10 @@ export class LikeC4ModelBuilder extends ADisposable {
       this.DocumentBuilder.onBuildPhase(
         DocumentState.Validated,
         (docs, _cancelToken) => {
-          logger.debug("onValidated ({docslength} docs)", { docslength: docs.length });
-          this.notifyListeners(docs.map((d) => d.uri));
+          const validated = docs.map(prop("uri")).filter(isNot(isLikeC4Builtin));
+          if (validated.length > 0) {
+            this.notifyListeners(validated);
+          }
         }
       )
     );
@@ -63,20 +71,25 @@ export class LikeC4ModelBuilder extends ADisposable {
     }
     const cache = this.cache;
     return cache.get(CACHE_KEY_PARSED_MODEL, () => {
-      logger.debug("unsafeSyncParseModel ({docslength} docs)", { docslength: docs.length });
-      const model = buildModel(docs);
-      const computeView = LikeC4Model.makeCompute(model);
-      return { model, computeView };
+      return buildModel(docs);
     });
   }
   async parseModel(cancelToken) {
     const cache = this.cache;
     const cached = cache.get(CACHE_KEY_PARSED_MODEL);
     if (cached) {
-      return await Promise.resolve(cached);
+      logger.debug("parseModel from cache");
+      return cached;
+    }
+    if (this.LangiumDocuments.all.some((doc) => doc.state < DocumentState.Validated)) {
+      logger.debug("parseModel: waiting for documents to be validated");
+      await this.DocumentBuilder.waitUntil(DocumentState.Validated, cancelToken);
+      logger.debug("parseModel: documents are validated");
     }
-    await this.DocumentBuilder.waitUntil(DocumentState.Validated, cancelToken);
-    return this.unsafeSyncParseModel();
+    const t0 = performance.now();
+    const result = this.unsafeSyncParseModel();
+    logger.debug(`parseModel in ${prettyMs(performance.now() - t0)}`);
+    return result;
   }
   previousViews = {};
   /**
@@ -85,20 +98,18 @@ export class LikeC4ModelBuilder extends ADisposable {
    * Otherwise, the model may be incomplete.
    */
   unsafeSyncBuildModel() {
-    const parsed = this.unsafeSyncParseModel();
-    if (!parsed) {
-      return LikeC4Model.EMPTY;
-    }
     const cache = this.cache;
     const viewsCache = this.cache;
     return cache.get(CACHE_KEY_COMPUTED_MODEL, () => {
+      const parsed = this.unsafeSyncParseModel();
+      if (!parsed) {
+        return LikeC4Model.EMPTY;
+      }
       const {
-        model: {
-          views: parsedViews,
-          ...model
-        },
-        computeView
+        views: parsedViews,
+        ...model
       } = parsed;
+      const computeView = LikeC4Model.makeCompute(parsed);
       const allViews = [];
       for (const view of values(parsedViews)) {
         const result = computeView(view);
@@ -126,13 +137,18 @@ export class LikeC4ModelBuilder extends ADisposable {
     const cache = this.cache;
     const cached = cache.get(CACHE_KEY_COMPUTED_MODEL);
     if (cached) {
-      return await Promise.resolve(cached);
+      logger.debug("buildLikeC4Model from cache");
+      return cached;
     }
+    const t0 = performance.now();
     const model = await this.parseModel(cancelToken);
     if (!model) {
+      logger.debug("buildLikeC4Model: no model");
       return LikeC4Model.EMPTY;
     }
-    return this.unsafeSyncBuildModel();
+    const result = this.unsafeSyncBuildModel();
+    logger.debug(`buildLikeC4Model in ${prettyMs(performance.now() - t0)}`);
+    return result;
   }
   async computeView(viewId, cancelToken) {
     const cache = this.cache;
@@ -145,19 +161,21 @@ export class LikeC4ModelBuilder extends ADisposable {
       return null;
     }
     return cache.get(cacheKey, () => {
-      const view = parsed.model.views[viewId];
+      const view = parsed.views[viewId];
       if (!view) {
-        logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
+        logger.warn`computeView: cant find view ${viewId}`;
         return null;
       }
-      const result = parsed.computeView(view);
+      logger.debug`computeView: ${viewId}`;
+      const computeView = LikeC4Model.makeCompute(parsed);
+      const result = computeView(view);
       if (!result.isSuccess) {
         logWarnError(result.error);
         return null;
       }
       let computedView = result.view;
       const allElementViews = pipe(
-        parsed.model.views,
+        parsed.views,
         values(),
         filter(isScopedElementView),
         filter((v) => v.id !== viewId),

package/dist/model/model-locator.d.ts

@@ -16,7 +16,7 @@ export declare class LikeC4ModelLocator {
     locateDeploymentElement(fqn: c4.Fqn, _prop?: string): Location | null;
     locateRelation(relationId: c4.RelationId): Location | null;
     locateViewAst(viewId: c4.ViewId): {
-        doc: any;
+        doc: Stream<import("../ast").ParsedLikeC4LangiumDocument>;
         view: any;
         viewAst: ast.LikeC4View;
     } | null;

package/dist/model/model-locator.js

@@ -16,7 +16,7 @@ export class LikeC4ModelLocator {
   langiumDocuments;
   parser;
   documents() {
-    return this.parser.documents().toArray();
+    return this.parser.documents();
   }
   getParsedElement(astNodeOrFqn) {
     if (isString(astNodeOrFqn)) {