@likec4/language-server 1.43.0 → 1.45.0

package/dist/model/deployments-index.js

@@ -0,0 +1,102 @@
+import { ancestorsFqn, Fqn } from '@likec4/core';
+import { MultiMap } from '@likec4/core/utils';
+import { isDefined, isTruthy } from 'remeda';
+import { ast, ElementOps, } from '../ast';
+import { logWarnError } from '../logger';
+import { readStrictFqn } from '../utils/elementRef';
+import { DocumentFqnIndex, FqnIndex } from './fqn-index';
+export class DeploymentsIndex extends FqnIndex {
+    services;
+    Names;
+    constructor(services) {
+        super(services);
+        this.services = services;
+        this.Names = services.references.NameProvider;
+    }
+    createDocumentIndex(document) {
+        const rootNodes = document.parseResult.value.deployments.flatMap(m => m.elements);
+        if (rootNodes.length === 0) {
+            return DocumentFqnIndex.EMPTY;
+        }
+        const projectId = this.projects.belongsTo(document);
+        const root = new Array();
+        const children = new MultiMap();
+        const descendants = new MultiMap();
+        const byfqn = new MultiMap();
+        const Names = this.Names;
+        const Descriptions = this.services.workspace.AstNodeDescriptionProvider;
+        const createAndSaveDescription = (node, name, fqn) => {
+            const desc = {
+                ...Descriptions.createDescription(node, name, document),
+                id: fqn,
+                likec4ProjectId: projectId,
+            };
+            ElementOps.writeId(node, fqn);
+            byfqn.set(fqn, desc);
+            return desc;
+        };
+        const traverseNode = (node, parentFqn) => {
+            let thisFqn;
+            if (ast.isExtendDeployment(node)) {
+                thisFqn = readStrictFqn(node.deploymentNode);
+            }
+            else {
+                const name = Names.getName(node);
+                if (!isTruthy(name)) {
+                    return [];
+                }
+                thisFqn = Fqn(name, parentFqn);
+                const desc = createAndSaveDescription(node, name, thisFqn);
+                if (!parentFqn) {
+                    root.push(desc);
+                }
+                else {
+                    children.set(parentFqn, desc);
+                }
+                if (ast.isDeployedInstance(node)) {
+                    return [];
+                }
+            }
+            let _nested = [];
+            if (isDefined(node.body)) {
+                for (const child of node.body.elements) {
+                    if (!ast.isDeploymentRelation(child)) {
+                        try {
+                            _nested.push(...traverseNode(child, thisFqn));
+                        }
+                        catch (e) {
+                            logWarnError(e);
+                        }
+                    }
+                }
+            }
+            _nested = [
+                ...children.get(thisFqn) ?? [],
+                ..._nested,
+            ];
+            for (const child of _nested) {
+                descendants.set(thisFqn, child);
+            }
+            if (ast.isExtendDeployment(node)) {
+                for (const ancestor of ancestorsFqn(thisFqn)) {
+                    for (const child of _nested) {
+                        descendants.set(ancestor, child);
+                    }
+                }
+            }
+            return descendants.get(thisFqn) ?? [];
+        };
+        for (const node of rootNodes) {
+            try {
+                if (ast.isDeploymentRelation(node)) {
+                    continue;
+                }
+                traverseNode(node, null);
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+        return new DocumentFqnIndex(root, children, descendants, byfqn, projectId);
+    }
+}

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

@@ -7,12 +7,11 @@ import { ADisposable } from '../utils';
 import { type LangiumDocuments, ProjectsManager } from '../workspace';
 export declare class FqnIndex<AstNd = ast.Element> extends ADisposable {
     protected services: LikeC4Services;
-    private cachePrefix;
     protected projects: ProjectsManager;
     protected langiumDocuments: LangiumDocuments;
     protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
     protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
-    constructor(services: LikeC4Services, cachePrefix?: string);
+    constructor(services: LikeC4Services);
     private documents;
     get(document: LikeC4LangiumDocument): DocumentFqnIndex;
     resolve(reference: ast.Referenceable): Fqn;

package/dist/model/fqn-index.js

@@ -0,0 +1,247 @@
+import { invariant, nonNullable } from '@likec4/core';
+import { Fqn } from '@likec4/core/types';
+import { ancestorsFqn, compareNatural, DefaultWeakMap, MultiMap, sortNaturalByFqn } from '@likec4/core/utils';
+import { AstUtils, DocumentState, stream, WorkspaceCache, } from 'langium';
+import { isDefined, isEmpty, isTruthy } from 'remeda';
+import { ast, ElementOps, isLikeC4LangiumDocument, } from '../ast';
+import { logWarnError } from '../logger';
+import { ADisposable } from '../utils';
+import { readStrictFqn } from '../utils/elementRef';
+import { ProjectsManager } from '../workspace';
+export class FqnIndex extends ADisposable {
+    services;
+    projects;
+    langiumDocuments;
+    documentCache;
+    workspaceCache;
+    constructor(services) {
+        super();
+        this.services = services;
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        this.projects = services.shared.workspace.ProjectsManager;
+        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, (doc) => {
+            if (isLikeC4LangiumDocument(doc)) {
+                this.documentCache.delete(doc);
+            }
+        }));
+    }
+    documents(projectId) {
+        return this.langiumDocuments.projectDocuments(projectId).filter((d) => isLikeC4LangiumDocument(d)
+            && d.state >= DocumentState.IndexedContent);
+    }
+    get(document) {
+        if (document.state < DocumentState.IndexedContent) {
+            logWarnError(`Document ${document.uri.path} is not indexed`);
+        }
+        return this.documentCache.get(document);
+    }
+    resolve(reference) {
+        if (reference.$type === 'Imported') {
+            return this.getFqn(reference.imported.ref);
+        }
+        if (reference.$type === 'Element') {
+            return this.getFqn(reference);
+        }
+        return this.services.likec4.DeploymentsIndex.getFqn(reference);
+    }
+    getFqn(el) {
+        invariant(ast.isElement(el) || ast.isDeploymentElement(el));
+        let id = ElementOps.readId(el);
+        if (isTruthy(id)) {
+            return id;
+        }
+        // Document index is not yet created
+        const doc = AstUtils.getDocument(el);
+        invariant(isLikeC4LangiumDocument(doc));
+        // Ensure the document is indexed
+        this.get(doc);
+        // This will create the document index
+        return nonNullable(ElementOps.readId(el), 'Element fqn must be set, invalid state');
+    }
+    byFqn(projectId, fqn) {
+        return stream(this.workspaceCache.get(`${projectId}:fqn:${fqn}`, () => {
+            return this
+                .documents(projectId)
+                .flatMap(doc => {
+                return this.get(doc).byFqn(fqn);
+            })
+                .toArray();
+        }));
+    }
+    rootElements(projectId) {
+        return stream(this.workspaceCache.get(`${projectId}:rootElements`, () => {
+            const allchildren = this.documents(projectId)
+                .reduce((map, doc) => {
+                this.get(doc).rootElements().forEach(desc => {
+                    map.set(desc.name, desc);
+                });
+                return map;
+            }, new MultiMap());
+            return uniqueByName(allchildren);
+        }));
+    }
+    directChildrenOf(projectId, parent) {
+        return stream(this.workspaceCache.get(`${projectId}:directChildrenOf:${parent}`, () => {
+            const allchildren = this.documents(projectId)
+                .reduce((map, doc) => {
+                this.get(doc).children(parent).forEach(desc => {
+                    map.set(desc.name, desc);
+                });
+                return map;
+            }, new MultiMap());
+            return uniqueByName(allchildren);
+        }));
+    }
+    /**
+     * Returns descedant elements with unique names in the scope
+     */
+    uniqueDescedants(projectId, parent) {
+        return stream(this.workspaceCache.get(`${projectId}:uniqueDescedants:${parent}`, () => {
+            const { children, descendants } = this.documents(projectId)
+                .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);
+            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);
+        if (rootElements.length === 0) {
+            return DocumentFqnIndex.EMPTY;
+        }
+        const projectId = document.likec4ProjectId ?? this.projects.belongsTo(document);
+        const root = new Array();
+        const children = new MultiMap();
+        const descendants = new MultiMap();
+        const byfqn = new MultiMap();
+        const Descriptions = this.services.workspace.AstNodeDescriptionProvider;
+        const createAndSaveDescription = (node, name, fqn) => {
+            const desc = Object.assign(Descriptions.createDescription(node, name, document), {
+                id: fqn,
+                likec4ProjectId: projectId,
+            });
+            ElementOps.writeId(node, fqn);
+            byfqn.set(fqn, desc);
+            return desc;
+        };
+        const traverseNode = (el, parentFqn) => {
+            let thisFqn;
+            if (ast.isElement(el)) {
+                thisFqn = Fqn(el.name, parentFqn);
+                const desc = createAndSaveDescription(el, el.name, thisFqn);
+                if (!parentFqn) {
+                    root.push(desc);
+                }
+                else {
+                    children.set(parentFqn, desc);
+                }
+            }
+            else {
+                thisFqn = readStrictFqn(el.element);
+            }
+            let _nested = [];
+            if (isDefined(el.body) && !isEmpty(el.body.elements)) {
+                for (const child of el.body.elements) {
+                    if (!ast.isRelation(child)) {
+                        try {
+                            _nested.push(...traverseNode(child, thisFqn));
+                        }
+                        catch (e) {
+                            logWarnError(e);
+                        }
+                    }
+                }
+            }
+            const directChildren = children.get(thisFqn) ?? [];
+            _nested = [
+                ...directChildren,
+                ..._nested,
+            ];
+            for (const child of _nested) {
+                descendants.set(thisFqn, child);
+            }
+            if (ast.isExtendElement(el)) {
+                for (const ancestor of ancestorsFqn(thisFqn)) {
+                    for (const child of _nested) {
+                        descendants.set(ancestor, child);
+                    }
+                }
+            }
+            return descendants.get(thisFqn) ?? [];
+        };
+        for (const node of rootElements) {
+            try {
+                if (ast.isRelation(node)) {
+                    continue;
+                }
+                traverseNode(node, null);
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+        return new DocumentFqnIndex(root, children, descendants, byfqn, projectId);
+    }
+}
+function uniqueByName(multimap) {
+    return [...multimap.associations()]
+        .flatMap(([_name, descs]) => (descs.length === 1 ? descs : []))
+        .sort((a, b) => compareNatural(a.name, b.name));
+}
+export class DocumentFqnIndex {
+    _rootElements;
+    _children;
+    _descendants;
+    _byfqn;
+    projectId;
+    static EMPTY = new DocumentFqnIndex([], new MultiMap(), new MultiMap(), new MultiMap(), ProjectsManager.DefaultProjectId);
+    constructor(_rootElements, 
+    /**
+     * direct children of elements
+     */
+    _children, 
+    /**
+     * All descendants of an element (unique by name)
+     */
+    _descendants, 
+    /**
+     * All elements by FQN
+     */
+    _byfqn, projectId) {
+        this._rootElements = _rootElements;
+        this._children = _children;
+        this._descendants = _descendants;
+        this._byfqn = _byfqn;
+        this.projectId = projectId;
+    }
+    rootElements() {
+        return this._rootElements;
+    }
+    byFqn(fqn) {
+        return this._byfqn.get(fqn) ?? [];
+    }
+    children(parent) {
+        return this._children.get(parent) ?? [];
+    }
+    descendants(nodeName) {
+        return this._descendants.get(nodeName) ?? [];
+    }
+}

package/dist/model/index.js

@@ -0,0 +1,6 @@
+export * from './deployments-index';
+export * from './fqn-index';
+export * from './model-builder';
+export * from './model-locator';
+export * from './model-parser';
+export * from './parser/ValueConverter';

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

@@ -1,17 +1,18 @@
-import { type ViewId } from '@likec4/core';
+import { type LayoutedView, type ProjectId, type UnknownComputed, type UnknownParsed, type ViewId } from '@likec4/core';
 import { LikeC4Model } from '@likec4/core/model';
 import type * as c4 from '@likec4/core/types';
 import { type URI, Disposable } from 'langium';
-import { CancellationToken } from 'vscode-jsonrpc';
+import type { CancellationToken } from 'vscode-jsonrpc';
 import type { LikeC4Services } from '../module';
 import { ADisposable } from '../utils';
 type ModelParsedListener = (docs: URI[]) => void;
+type ManualLayouts = Record<ViewId, LayoutedView> | null;
 export interface LikeC4ModelBuilder extends Disposable {
-    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Parsed | null>;
-    unsafeSyncBuildModel(projectId: c4.ProjectId): LikeC4Model.Computed;
-    buildLikeC4Model(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Computed>;
-    computeView(viewId: ViewId, projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ComputedView | null>;
+    parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownParsed> | null>;
+    unsafeSyncComputeModel(projectId: ProjectId): LikeC4Model<UnknownComputed>;
+    computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;
     onModelParsed(callback: ModelParsedListener): Disposable;
+    clearCache(): void;
 }
 export declare class DefaultLikeC4ModelBuilder extends ADisposable implements LikeC4ModelBuilder {
     private projects;
@@ -19,6 +20,7 @@ export declare class DefaultLikeC4ModelBuilder extends ADisposable implements Li
     private listeners;
     private cache;
     private DocumentBuilder;
+    private manualLayouts;
     private mutex;
     constructor(services: LikeC4Services);
     /**
@@ -32,18 +34,18 @@ export declare class DefaultLikeC4ModelBuilder extends ADisposable implements Li
     /**
      * To avoid circular dependencies, first we parse all documents and then we join them.
      */
-    private unsafeSyncJoinedModelData;
-    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Parsed | null>;
+    private unsafeSyncJoinedModel;
+    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownParsed> | null>;
     private previousViews;
     /**
      * WARNING:
      * This method is internal and should to be called only when all documents are known to be parsed.
      * Otherwise, the model may be incomplete.
      */
-    unsafeSyncBuildModel(projectId: c4.ProjectId): LikeC4Model.Computed;
-    buildLikeC4Model(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Computed>;
-    computeView(viewId: ViewId, projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ComputedView | null>;
+    unsafeSyncComputeModel(projectId: c4.ProjectId, manualLayouts?: ManualLayouts): LikeC4Model<UnknownComputed>;
+    computeModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;
     onModelParsed(callback: ModelParsedListener): Disposable;
+    clearCache(): void;
     private documents;
     private notifyListeners;
 }

package/dist/model/model-builder.js

@@ -0,0 +1,232 @@
+import { _stage, } from '@likec4/core';
+import { computeView } from '@likec4/core/compute-view';
+import { LikeC4Model } from '@likec4/core/model';
+import { loggable } from '@likec4/log';
+import { deepEqual as eq } from 'fast-equals';
+import { Disposable, DocumentState, interruptAndCheck, WorkspaceCache, } from 'langium';
+import { flatMap, hasAtLeast, isEmpty, mapToObj, pipe, values, } from 'remeda';
+import { isLikeC4Builtin } from '../likec4lib';
+import { logger as mainLogger } from '../logger';
+import { ADisposable, performanceMark } from '../utils';
+import { assignNavigateTo } from '../view-utils';
+import { buildModelData } from './builder/buildModel';
+const parsedWithoutImportsCacheKey = (projectId) => `parsed-without-imports-${projectId}`;
+const parsedModelCacheKey = (projectId) => `parsed-model-${projectId}`;
+const computedModelCacheKey = (projectId) => `computed-model-${projectId}`;
+const builderLogger = mainLogger.getChild('model-builder');
+export class DefaultLikeC4ModelBuilder extends ADisposable {
+    projects;
+    parser;
+    listeners = [];
+    cache;
+    DocumentBuilder;
+    manualLayouts;
+    mutex;
+    constructor(services) {
+        super();
+        this.projects = services.shared.workspace.ProjectsManager;
+        this.parser = services.likec4.ModelParser;
+        this.cache = services.shared.workspace.Cache;
+        this.DocumentBuilder = services.shared.workspace.DocumentBuilder;
+        this.mutex = services.shared.workspace.WorkspaceLock;
+        this.manualLayouts = services.likec4.ManualLayouts;
+        this.onDispose(this.DocumentBuilder.onUpdate((_changed, deleted) => {
+            if (deleted.length > 0) {
+                this.notifyListeners(deleted);
+            }
+        }));
+        this.onDispose(this.DocumentBuilder.onBuildPhase(DocumentState.Validated, (docs, _cancelToken) => {
+            const validated = docs.flatMap(d => isLikeC4Builtin(d.uri) || this.projects.isExcluded(d) ? [] : d.uri);
+            if (validated.length > 0) {
+                this.notifyListeners(validated);
+            }
+        }));
+        builderLogger.debug `created`;
+    }
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     *
+     * To avoid circular dependencies, we do not resolve imports here.
+     */
+    unsafeSyncParseModelData(projectId) {
+        const cache = this.cache;
+        const logger = builderLogger.getChild(projectId);
+        const key = parsedWithoutImportsCacheKey(projectId);
+        if (cache.has(key)) {
+            logger.debug `unsafeSyncParseModelData from cache`;
+        }
+        return cache.get(key, () => {
+            try {
+                const project = this.projects.getProject(projectId);
+                const docs = this.documents(projectId);
+                if (docs.length === 0) {
+                    logger.debug `no documents to build model`;
+                    return null;
+                }
+                logger.debug `unsafeSyncParseModelData`;
+                return buildModelData(project, docs);
+            }
+            catch (err) {
+                builderLogger.warn(`unsafeSyncParseModelData failed for project ${projectId}`, { err });
+                return null;
+            }
+        });
+    }
+    /**
+     * To avoid circular dependencies, first we parse all documents and then we join them.
+     */
+    unsafeSyncJoinedModel(projectId) {
+        const logger = builderLogger.getChild(projectId);
+        const cache = this.cache;
+        const key = parsedModelCacheKey(projectId);
+        if (cache.has(key)) {
+            logger.debug `unsafeSyncJoinedModel from cache`;
+        }
+        return cache.get(key, () => {
+            const result = this.unsafeSyncParseModelData(projectId);
+            if (!result) {
+                return null;
+            }
+            let parsedData = result.data;
+            if (result.imports.size > 0) {
+                logger.debug `processing imports of ${projectId}`;
+                const imports = [...result.imports.associations()].reduce((acc, [projectId, fqns]) => {
+                    const anotherProject = this.unsafeSyncParseModelData(projectId);
+                    if (anotherProject) {
+                        const imported = pipe([...fqns], flatMap(fqn => anotherProject.data.elements[fqn] ?? []));
+                        if (hasAtLeast(imported, 1)) {
+                            acc[projectId] = imported;
+                        }
+                    }
+                    return acc;
+                }, {});
+                parsedData = {
+                    ...result.data,
+                    imports,
+                };
+            }
+            return LikeC4Model.create(parsedData);
+        });
+    }
+    async parseModel(projectId, cancelToken) {
+        projectId = this.projects.ensureProjectId(projectId);
+        const logger = builderLogger.getChild(projectId);
+        const t0 = performanceMark();
+        return await this.mutex.read(async () => {
+            if (cancelToken?.isCancellationRequested) {
+                await interruptAndCheck(cancelToken);
+            }
+            const parsedModel = this.unsafeSyncJoinedModel(projectId);
+            logger.debug `parseModel in ${t0.pretty}`;
+            return parsedModel;
+        });
+    }
+    previousViews = {};
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncComputeModel(projectId, manualLayouts) {
+        const logger = builderLogger.getChild(projectId);
+        const cache = this.cache;
+        const hasManualLayouts = !!manualLayouts && !isEmpty(manualLayouts);
+        const key = computedModelCacheKey(projectId) + (hasManualLayouts ? '+manualLayouts' : '');
+        if (cache.has(key)) {
+            logger.debug `unsafeSyncBuildModel from cache`;
+        }
+        return cache.get(key, () => {
+            const parsedModel = this.unsafeSyncJoinedModel(projectId);
+            if (!parsedModel) {
+                return LikeC4Model.EMPTY.asComputed;
+            }
+            const allViews = [];
+            for (const view of values(parsedModel.$data.views)) {
+                const result = computeView(view, parsedModel);
+                if (!result.isSuccess) {
+                    logger.warn(loggable(result.error));
+                    continue;
+                }
+                if (manualLayouts?.[view.id]) {
+                    Object.assign(result.view, 
+                    // satisfies enforces that the object has the property
+                    { hasManualLayout: true });
+                }
+                allViews.push(result.view);
+            }
+            assignNavigateTo(allViews);
+            const views = mapToObj(allViews, v => {
+                const key = computedViewKey(projectId, v.id);
+                const previous = this.previousViews[key];
+                const view = previous && eq(v, previous) ? previous : v;
+                this.previousViews[key] = view;
+                return [v.id, view];
+            });
+            const data = {
+                ...parsedModel.$data,
+                [_stage]: 'computed',
+                views,
+            };
+            if (hasManualLayouts) {
+                data.manualLayouts = manualLayouts;
+            }
+            return LikeC4Model.create(data);
+        });
+    }
+    async computeModel(projectId, cancelToken) {
+        projectId = this.projects.ensureProjectId(projectId);
+        const logger = builderLogger.getChild(projectId);
+        const t0 = performanceMark();
+        return await this.mutex.read(async () => {
+            if (cancelToken?.isCancellationRequested) {
+                await interruptAndCheck(cancelToken);
+            }
+            const project = this.projects.getProject(projectId);
+            const manualLayouts = await this.manualLayouts.read(project);
+            const result = this.unsafeSyncComputeModel(projectId, manualLayouts);
+            logger.debug(`buildLikeC4Model in ${t0.pretty}`);
+            return result;
+        });
+    }
+    // public async rebuildProject(projectId?: c4.ProjectId | undefined): Promise<void> {
+    //   await this.mutex.write(async (token) => {
+    //     projectId = this.projects.ensureProjectId(projectId)
+    //     this.clearCache()
+    //     builderLogger.debug(`rebuildProject ${projectId}`)
+    //     const docs = this.documents(projectId).map(doc => doc.uri)
+    //     await this.DocumentBuilder.update(docs, [], token)
+    //   })
+    // }
+    onModelParsed(callback) {
+        this.listeners.push(callback);
+        return Disposable.create(() => {
+            const index = this.listeners.indexOf(callback);
+            if (index >= 0) {
+                this.listeners.splice(index, 1);
+            }
+        });
+    }
+    clearCache() {
+        builderLogger.debug(`clearCache`);
+        this.cache.clear();
+        this.previousViews = {};
+    }
+    documents(projectId) {
+        return this.parser.documents(projectId).toArray();
+    }
+    notifyListeners(docs) {
+        for (const listener of this.listeners) {
+            try {
+                listener(docs);
+            }
+            catch (e) {
+                builderLogger.warn(loggable(e));
+            }
+        }
+    }
+}
+function computedViewKey(projectId, viewId) {
+    return `computed-view-${projectId}-${viewId}`;
+}

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

@@ -5,6 +5,11 @@ import { URI } from 'vscode-uri';
 import type { ParsedAstElement, ParsedAstView, ParsedLikeC4LangiumDocument } from '../ast';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
+export type ViewLocateResult = {
+    doc: ParsedLikeC4LangiumDocument;
+    view: ParsedAstView;
+    viewAst: ast.LikeC4View;
+};
 export declare class LikeC4ModelLocator {
     private services;
     private fqnIndex;
@@ -18,11 +23,7 @@ export declare class LikeC4ModelLocator {
     locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
     locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
     locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
-    locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | {
-        doc: ParsedLikeC4LangiumDocument;
-        view: ParsedAstView;
-        viewAst: ast.LikeC4View;
-    };
+    locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
     locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
     locateDocumentTags(documentUri: URI, cancelToken?: Cancellation.CancellationToken): Promise<Array<{
         name: string;