@likec4/language-server 0.6.3 → 0.8.0

package/dist/model/fqn-index.js

@@ -1,48 +1,80 @@
-import { DocumentState, DONE_RESULT, MultiMap, StreamImpl } from 'langium';
-import { ast, ElementOps } from '../ast';
+import { DocumentState, DONE_RESULT, getDocument, MultiMap, StreamImpl } from 'langium';
+import { ElementOps, isLikeC4LangiumDocument } from '../ast';
 import { logger } from '../logger';
-import { parentFqn } from '@likec4/core/utils';
-import { Fqn } from '@likec4/core/types';
-import { strictElementRefFqn } from '../elementRef';
+import { nameFromFqn, parentFqn } from '@likec4/core/utils';
+import '../elementRef';
+import { isNil } from 'rambdax';
+import '../generated/ast';
+const isFqnIndexedDocument = (doc) => isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.ComputedScopes && !isNil(doc.c4fqns);
 export class FqnIndex {
     services;
     // #fqnMap = new WeakMap<ast.Element, Fqn>()
-    #index = new MultiMap();
-    descriptions;
+    // protected readonly descriptions: AstNodeDescriptionProvider
     constructor(services) {
         this.services = services;
-        this.descriptions = services.workspace.AstNodeDescriptionProvider;
-        services.shared.workspace.DocumentBuilder.onUpdate((_changed, removed) => {
-            for (const uri of [...removed]) {
-                this.cleanIndexedElements(uri);
-            }
-        });
-        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.ComputedScopes, (docs, _cancelToken) => {
-            for (const doc of docs) {
-                this.cleanIndexedElements(doc.uri);
-                this.doIndexElements(doc);
-            }
-        });
+        // this.descriptions = services.workspace.AstNodeDescriptionProvider
+        // services.shared.workspace.DocumentBuilder.onUpdate((_changed, removed) => {
+        //   for (const uri of [..._changed, ...removed]) {
+        //     this.cleanIndexedElements(uri)
+        //   }
+        // })
+        // services.shared.workspace.DocumentBuilder.onBuildPhase(
+        //   DocumentState.Parsed,
+        //   (docs, _cancelToken) => {
+        //     for (const doc of docs) {
+        //       this.cleanIndexedElements(doc.uri)
+        //       this.doIndexElements(doc as LikeC4LangiumDocument)
+        //     }
+        //   }
+        // )
+    }
+    documents() {
+        return this.services.shared.workspace.LangiumDocuments.all.filter(isFqnIndexedDocument);
+    }
+    entries() {
+        return this.documents().flatMap(doc => doc.c4fqns.entries().map(([fqn, path]) => ({ fqn, path, doc })));
     }
+    // private index() {
+    //   const index = new MultiMap<Fqn, {
+    //     path: string,
+    //     doc: LikeC4LangiumDocument
+    //   }>()
+    //   this.entries().toMap()
+    //   this.entries().forEach(({ fqn, path, doc }) => {
+    //     index.add(fqn, { path, doc })
+    //   })
+    //   // for (const doc of this.documents()) {
+    //   //   doc.c4fqns.entries().forEach(([fqn, path]) => {
+    //   //     index.add(fqn, { path, doc })
+    //   //   })
+    //   // }
+    //   return index
+    // }
     get(el) {
         let fqn = ElementOps.readId(el) ?? null;
-        // if ()
-        // let fqn = this.#fqnMap.get(el) ?? null
-        if (fqn && !this.#index.has(fqn)) {
+        const doc = getDocument(el);
+        if (fqn) {
+            if (isFqnIndexedDocument(doc) && doc.c4fqns.has(fqn)) {
+                return fqn;
+            }
             const path = this.services.workspace.AstNodeLocator.getAstNodePath(el);
             logger.error(`Clean cached FQN ${fqn} at ${path}`);
-            // this.#fqnMap.delete(el)
+            ElementOps.writeId(el, null);
             fqn = null;
         }
         return fqn;
     }
     byFqn(fqn) {
-        return this.#index.get(fqn);
+        return this.documents()
+            .flatMap(doc => {
+            return doc.c4fqns.get(fqn).map(path => ({ path, doc }));
+        });
     }
     directChildrenOf(parent) {
-        return this.#index
-            .entriesGroupedByKey()
-            .flatMap(([fqn, descrs]) => (descrs.length === 1 && parentFqn(fqn) === parent ? descrs : []));
+        return this
+            .entries()
+            .filter(e => parentFqn(e.fqn) === parent)
+            .map((e) => ({ ...e, name: nameFromFqn(e.fqn) }));
     }
     uniqueDescedants(parent) {
         return new StreamImpl(() => {
@@ -50,24 +82,26 @@ export class FqnIndex {
             const children = [];
             const childrenNames = new Set();
             const descedants = [];
-            this.#index.entries().forEach(([fqn, desc]) => {
-                if (fqn.startsWith(prefix)) {
-                    if (parentFqn(fqn) === parent) {
-                        childrenNames.add(desc.name);
-                        children.push([fqn, desc]);
+            this.entries().forEach(e => {
+                if (e.fqn.startsWith(prefix)) {
+                    const name = nameFromFqn(e.fqn);
+                    const entry = { ...e, name };
+                    if (parentFqn(e.fqn) === parent) {
+                        childrenNames.add(name);
+                        children.push(entry);
                     }
                     else {
-                        descedants.push([fqn, desc]);
+                        descedants.push(entry);
                     }
                 }
             });
             if (children.length + descedants.length === 0) {
                 return null;
             }
-            const nested = new MultiMap(children.map(([_fqn, desc]) => [desc.name, desc]));
-            for (const [_, indexed] of descedants) {
-                if (!childrenNames.has(indexed.name)) {
-                    nested.add(indexed.name, indexed);
+            const nested = new MultiMap(children.map(entry => [entry.name, entry]));
+            for (const descedant of descedants) {
+                if (!childrenNames.has(descedant.name)) {
+                    nested.add(descedant.name, descedant);
                 }
             }
             return nested
@@ -81,58 +115,5 @@ export class FqnIndex {
             return DONE_RESULT;
         });
     }
-    doIndexElements(doc) {
-        const visitElement = (element, parent = null) => {
-            try {
-                const name = element.name;
-                const fqn = Fqn(name, parent);
-                this.#index.add(fqn, this.descriptions.createDescription(element, name, doc));
-                ElementOps.writeId(element, fqn);
-                // this.#fqnMap.set(element, fqn)
-                if (element.body) {
-                    for (const nested of element.body.elements) {
-                        if (ast.isElement(nested)) {
-                            visitElement(nested, fqn);
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn(e);
-            }
-        };
-        const visitExtendElement = (extendElement) => {
-            try {
-                const fqn = strictElementRefFqn(extendElement.element);
-                for (const nested of extendElement.body.elements) {
-                    if (ast.isElement(nested)) {
-                        visitElement(nested, fqn);
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn(e);
-            }
-        };
-        const elements = doc.parseResult.value.model?.elements ?? [];
-        for (const modelElement of elements) {
-            if (ast.isExtendElement(modelElement)) {
-                visitExtendElement(modelElement);
-                continue;
-            }
-            if (ast.isElement(modelElement)) {
-                visitElement(modelElement);
-                continue;
-            }
-        }
-    }
-    cleanIndexedElements(docUri) {
-        const docUriAsString = docUri.toString();
-        const toDelete = this.#index
-            .entries()
-            .filter(([, indexed]) => indexed.documentUri.toString() === docUriAsString);
-        for (const [fqn, indexed] of toDelete.toArray()) {
-            this.#index.delete(fqn, indexed);
-        }
-    }
 }
+//# sourceMappingURL=fqn-index.js.map

package/dist/model/index.d.ts

@@ -1,3 +1,4 @@
 export * from './fqn-index';
 export * from './model-builder';
 export * from './model-locator';
+//# sourceMappingURL=index.d.ts.map

package/dist/model/index.js

@@ -1,3 +1,4 @@
 export * from './fqn-index';
 export * from './model-builder';
 export * from './model-locator';
+//# sourceMappingURL=index.js.map

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

@@ -24,3 +24,4 @@ export declare class LikeC4ModelBuilder {
     private convertTags;
     private notifyClient;
 }
+//# sourceMappingURL=model-builder.d.ts.map

package/dist/model/model-builder.js

@@ -10,7 +10,7 @@ import { toAutoLayout } from '../ast';
 import { ElementViewOps, ast, c4hash, cleanParsedModel, isLikeC4LangiumDocument, isParsedLikeC4LangiumDocument, resolveRelationPoints, streamModel, toElementStyle } from '../ast';
 import { elementRef, strictElementRefFqn } from '../elementRef';
 import { logger } from '../logger';
-import { Rpc } from '@likec4/language-protocol';
+import { Rpc } from '../protocol';
 import { failExpectedNever } from '../utils';
 export class LikeC4ModelBuilder {
     services;
@@ -79,13 +79,17 @@ export class LikeC4ModelBuilder {
             const elements = pipe(docs.flatMap(d => d.c4Elements), A.filterMap(flow(toModelElement, O.fromNullable)), A.sort(compareByFqnHierarchically), A.reduce({}, (acc, el) => {
                 const parent = parentFqn(el.id);
                 if (!parent || parent in acc) {
-                    invariant(!(el.id in acc), 'Duplicate element id: ' + el.id);
+                    if (el.id in acc) {
+                        logger.warn(`Duplicate element id: ${el.id}`);
+                    }
                     acc[el.id] = el;
                 }
                 return acc;
             }));
             const relations = pipe(docs.flatMap(d => d.c4Relations), A.filterMap(flow(toModelRelation, O.fromPredicate(({ source, target }) => source in elements && target in elements))), A.reduce({}, (acc, el) => {
-                invariant(!(el.id in acc), 'Duplicate relation id: ' + el.id);
+                if (el.id in acc) {
+                    logger.warn(`Duplicate relation id: ${el.id}`);
+                }
                 acc[el.id] = el;
                 return acc;
             }));
@@ -95,13 +99,15 @@ export class LikeC4ModelBuilder {
                     title = elements[view.viewOf]?.title;
                 }
                 return {
-                    ...omit(['astPath', 'rules', 'tite'], view),
+                    ...omit(['astPath', 'rules', 'title'], view),
                     ...(!!title ? { title } : {}),
                     rules: clone(view.rules)
                 };
             };
             const views = pipe(docs.flatMap(d => d.c4Views), A.filterMap(flow(toModelView, O.fromPredicate(v => isNil(v.viewOf) || v.viewOf in elements))), A.reduce({}, (acc, v) => {
-                invariant(!(v.id in acc), 'Duplicate view id: ' + v.id);
+                if (v.id in acc) {
+                    logger.warn(`Duplicate view id: ${v.id}`);
+                }
                 acc[v.id] = v;
                 return acc;
             }));
@@ -330,3 +336,4 @@ export class LikeC4ModelBuilder {
         await connection.sendNotification(Rpc.onDidChangeModel);
     }
 }
+//# sourceMappingURL=model-builder.js.map

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

@@ -1,5 +1,5 @@
 import type * as c4 from '@likec4/core/types';
-import type { Location } from 'vscode-languageserver-protocol';
+import type { Location } from 'vscode-languageserver';
 import type { ParsedAstElement } from '../ast';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
@@ -14,3 +14,4 @@ export declare class LikeC4ModelLocator {
     locateRelation(relationId: c4.RelationID): Location | null;
     locateView(viewId: c4.ViewID): Location | null;
 }
+//# sourceMappingURL=model-locator.d.ts.map

package/dist/model/model-locator.js

@@ -1,6 +1,4 @@
-import { getDocument } from 'langium';
-import { findNodeForKeyword, findNodeForProperty } from 'langium';
-import { head } from 'rambdax';
+import { findNodeForKeyword, findNodeForProperty, getDocument } from 'langium';
 import { ast, isParsedLikeC4LangiumDocument } from '../ast';
 export class LikeC4ModelLocator {
     services;
@@ -25,19 +23,28 @@ export class LikeC4ModelLocator {
         return doc.c4Elements.find(e => e.id === fqn) ?? null;
     }
     locateElement(fqn, property = 'name') {
-        const descr = head(this.fqnIndex.byFqn(fqn));
-        if (!descr)
-            return null;
-        const docUri = descr.documentUri.toString();
-        const doc = this.documents().find(d => d.uri.toString() === docUri);
-        const node = doc && this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, descr.path);
-        if (!ast.isElement(node) || !node.$cstNode)
-            return null;
-        const propertyNode = findNodeForProperty(node.$cstNode, property);
-        return {
-            uri: docUri,
-            range: propertyNode?.range ?? node.$cstNode.range
-        };
+        for (const doc of this.documents()) {
+            if (doc.c4fqns && !doc.c4fqns.has(fqn)) {
+                continue;
+            }
+            const element = doc.c4Elements.find(e => e.id === fqn);
+            if (!element) {
+                continue;
+            }
+            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, element.astPath);
+            if (!ast.isElement(node)) {
+                continue;
+            }
+            const propertyNode = findNodeForProperty(node.$cstNode, property) ?? node.$cstNode;
+            if (!propertyNode) {
+                return null;
+            }
+            return {
+                uri: doc.uri.toString(),
+                range: propertyNode.range
+            };
+        }
+        return null;
     }
     locateRelation(relationId) {
         for (const doc of this.documents()) {
@@ -106,3 +113,4 @@ export class LikeC4ModelLocator {
         return null;
     }
 }
+//# sourceMappingURL=model-locator.js.map

package/dist/module.d.ts

@@ -18,3 +18,4 @@ export declare function createLanguageServices(context?: LanguageServicesContext
     likec4: LikeC4Services;
 };
 export {};
+//# sourceMappingURL=module.d.ts.map

package/dist/module.js

@@ -63,3 +63,4 @@ export function createLanguageServices(context) {
     registerProtocolHandlers(likec4);
     return { shared, likec4 };
 }
+//# sourceMappingURL=module.js.map

package/dist/protocol.d.ts

@@ -0,0 +1,37 @@
+import type { Fqn, LikeC4Model, RelationID, ViewID } from '@likec4/core';
+import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
+import { NotificationType0, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+export declare const onDidChangeModel: NotificationType0;
+export declare const fetchModel: RequestType0<{
+    model: LikeC4Model | null;
+}, void>;
+export interface BuildDocumentsParams {
+    docs: DocumentUri[];
+}
+export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
+export interface LocateElementParams {
+    element: Fqn;
+    property?: string;
+}
+export declare const locateElement: RequestType<LocateElementParams, Location | null, void>;
+export declare const locateRelation: RequestType<{
+    id: RelationID;
+}, Location | null, void>;
+export declare const locateView: RequestType<{
+    id: ViewID;
+}, Location | null, void>;
+export declare const Rpc: {
+    readonly onDidChangeModel: NotificationType0;
+    readonly fetchModel: RequestType0<{
+        model: LikeC4Model | null;
+    }, void>;
+    readonly buildDocuments: RequestType<BuildDocumentsParams, void, void>;
+    readonly locateElement: RequestType<LocateElementParams, Location | null, void>;
+    readonly locateRelation: RequestType<{
+        id: RelationID;
+    }, Location | null, void>;
+    readonly locateView: RequestType<{
+        id: ViewID;
+    }, Location | null, void>;
+};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -0,0 +1,20 @@
+import { NotificationType0, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+//#region From server
+export const onDidChangeModel = new NotificationType0('likec4/onDidChangeModel');
+//#endregion
+//#region To server
+export const fetchModel = new RequestType0('likec4/fetchModel');
+export const buildDocuments = new RequestType('likec4/buildDocuments');
+export const locateElement = new RequestType('likec4/locateElement');
+export const locateRelation = new RequestType('likec4/locateRelation');
+export const locateView = new RequestType('likec4/locateView');
+//#endregion
+export const Rpc = {
+    onDidChangeModel,
+    fetchModel,
+    buildDocuments,
+    locateElement,
+    locateRelation,
+    locateView
+};
+//# sourceMappingURL=protocol.js.map

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

@@ -0,0 +1,4 @@
+import { type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services): void;
+//# sourceMappingURL=fqn-computation.d.ts.map

package/dist/references/fqn-computation.js

@@ -0,0 +1,41 @@
+import { failExpectedNever } from '@likec4/core';
+import { Fqn } from '@likec4/core/types';
+import { MultiMap } from 'langium';
+import { isEmpty, isNil } from 'rambdax';
+import { ElementOps, ast } from '../ast';
+import { strictElementRefFqn } from '../elementRef';
+export function computeDocumentFqn(document, services) {
+    const { model } = document.parseResult.value;
+    if (!model?.elements) {
+        return;
+    }
+    const c4fqns = document.c4fqns = new MultiMap();
+    const locator = services.workspace.AstNodeLocator;
+    const traverseStack = model.elements.map(el => [el, null]);
+    let pair;
+    while ((pair = traverseStack.shift())) {
+        const [el, parent] = pair;
+        if (ast.isRelation(el)) {
+            continue;
+        }
+        if (ast.isExtendElement(el)) {
+            if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+                const fqn = strictElementRefFqn(el.element);
+                el.body.elements.forEach(child => traverseStack.push([child, fqn]));
+            }
+            continue;
+        }
+        if (ast.isElement(el)) {
+            const fqn = Fqn(el.name, parent);
+            const path = locator.getAstNodePath(el);
+            c4fqns.add(fqn, path);
+            ElementOps.writeId(el, fqn);
+            if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+                el.body.elements.forEach(child => traverseStack.push([child, fqn]));
+            }
+            continue;
+        }
+        failExpectedNever(el);
+    }
+}
+//# sourceMappingURL=fqn-computation.js.map

package/dist/references/index.d.ts

@@ -1,2 +1,3 @@
 export * from './scope-computation';
 export * from './scope-provider';
+//# sourceMappingURL=index.d.ts.map

package/dist/references/index.js

@@ -1,2 +1,3 @@
 export * from './scope-computation';
 export * from './scope-provider';
+//# sourceMappingURL=index.js.map

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

@@ -1,10 +1,14 @@
 import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
-import type { CancellationToken } from 'vscode-languageserver-protocol';
+import type { CancellationToken } from 'vscode-languageserver';
 import { ast, type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
 export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+    private services;
+    constructor(services: LikeC4Services);
     computeExports(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<AstNodeDescription[]>;
     computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<PrecomputedScopes>;
     protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
 }
 export {};
+//# sourceMappingURL=scope-computation.d.ts.map

package/dist/references/scope-computation.js

@@ -1,9 +1,12 @@
 import { DefaultScopeComputation, MultiMap } from 'langium';
 import { ast } from '../ast';
+import { computeDocumentFqn } from './fqn-computation';
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
-    // constructor(services: LikeC4Services) {
-    //   super(services)
-    // }
+    services;
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
     computeExports(document, _cancelToken) {
         const { specification, model, views } = document.parseResult.value;
         const docExports = [];
@@ -16,13 +19,19 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
                 docExports.push(this.descriptions.createDescription(tag, '#' + tag.name, document));
             }
         }
+        document.c4fqns = undefined;
         if (model) {
             for (const elAst of model.elements) {
                 if (ast.isElement(elAst)) {
                     docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
                 }
             }
+            computeDocumentFqn(document, this.services);
         }
+        // const c4fqns = document.c4fqns
+        // logger.debug(`doc ${document.uri.path}:
+        //  fqns: ${c4fqns ? Array.from(c4fqns.keys()).join(', ') : '--'}
+        // `)
         if (views) {
             for (const viewAst of views.views) {
                 if ('name' in viewAst) {
@@ -74,3 +83,4 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         return localScope;
     }
 }
+//# sourceMappingURL=scope-computation.js.map

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

@@ -4,7 +4,10 @@ import type { LikeC4Services } from '../module';
 export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     private fqnIndex;
     constructor(services: LikeC4Services);
+    private directChildrenOf;
+    private uniqueDescedants;
     private scopeElementRef;
+    private scopeExtendElement;
     private scopeElementView;
     getScope(context: ReferenceInfo): Scope;
     protected computeScope(node: AstNode, referenceType: string): Scope;
@@ -13,3 +16,4 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
      */
     protected getGlobalScope(referenceType: string): Scope;
 }
+//# sourceMappingURL=scope-provider.d.ts.map