@likec4/language-server 0.33.1 → 0.35.0

package/dist/model/fqn-computation.js

@@ -1,5 +1,4 @@
-import { nonexhaustive } from '@likec4/core/errors';
-import { AsFqn } from '@likec4/core/types';
+import { AsFqn, nonexhaustive } from '@likec4/core';
 import { MultiMap } from 'langium';
 import { isEmpty, isNil } from 'remeda';
 import { ElementOps, ast } from '../ast';
@@ -28,7 +27,11 @@ export function computeDocumentFqn(document, services) {
         if (ast.isElement(el)) {
             const fqn = AsFqn(el.name, parent);
             const path = locator.getAstNodePath(el);
-            c4fqns.add(fqn, path);
+            c4fqns.add(fqn, {
+                el: new WeakRef(el),
+                path,
+                name: el.name
+            });
             ElementOps.writeId(el, fqn);
             if (!isNil(el.body) && !isEmpty(el.body.elements)) {
                 el.body.elements.forEach(child => traverseStack.push([child, fqn]));

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

@@ -3,14 +3,15 @@ import type { LangiumDocument, LangiumDocuments, Stream } from 'langium';
 import type { ast } from '../ast';
 import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
-type FqnIndexedDocument = Omit<LikeC4LangiumDocument, 'c4fqns'> & {
+export type FqnIndexedDocument = Omit<LikeC4LangiumDocument, 'c4fqns'> & {
     c4fqns: NonNullable<LikeC4LangiumDocument['c4fqns']>;
 };
 export declare function isFqnIndexedDocument(doc: LangiumDocument): doc is FqnIndexedDocument;
 export interface FqnIndexEntry {
     fqn: Fqn;
     name: string;
-    doc: LikeC4LangiumDocument;
+    el: ast.Element;
+    doc: FqnIndexedDocument;
     path: string;
 }
 export declare class FqnIndex {
@@ -19,15 +20,11 @@ export declare class FqnIndex {
     private documents;
     private entries;
     getFqn(el: ast.Element): Fqn | null;
-    byFqn(fqn: Fqn): Stream<{
-        path: string;
-        doc: LikeC4LangiumDocument;
-    }>;
+    byFqn(fqn: Fqn): Stream<FqnIndexEntry>;
     directChildrenOf(parent: Fqn): Stream<FqnIndexEntry>;
     /**
      * Returns descedant elements with unique names in the scope
      */
     uniqueDescedants(parent: Fqn): Stream<FqnIndexEntry>;
 }
-export {};
 //# sourceMappingURL=fqn-index.d.ts.map

package/dist/model/fqn-index.js

@@ -1,24 +1,48 @@
 import { nameFromFqn, parentFqn } from '@likec4/core';
-import { DONE_RESULT, DocumentState, MultiMap, StreamImpl } from 'langium';
+import { DONE_RESULT, DocumentState, MultiMap, StreamImpl, stream } from 'langium';
 import { isNil } from 'remeda';
 import { ElementOps, isLikeC4LangiumDocument } from '../ast';
-import { logger } from '../logger';
+import { logError, logger } from '../logger';
+import { printDocs } from '../utils';
 import { computeDocumentFqn } from './fqn-computation';
 export function isFqnIndexedDocument(doc) {
-    return (isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns));
+    return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns);
 }
 export class FqnIndex {
     langiumDocuments;
     constructor(services) {
         this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        // services.shared.workspace.DocumentBuilder.onUpdate((changed,deleted) => {
+        //   logger.debug('') // empty line to separate batches
+        //   logger.debug(`[DocumentBuilder.onUpdate]`)
+        //   if (changed.length > 0) {
+        //     logger.debug(` changed:\n` + changed.map(u => '  - ' + Utils.basename(u)).join('\n'))
+        //   }
+        //   if (deleted.length > 0) {
+        //     logger.debug(` deleted:\n` + deleted.map(u => '  - ' + Utils.basename(u)).join('\n'))
+        //   }
+        // })
+        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Changed, (docs, _cancelToken) => {
+            logger.debug(`[FqnIndex] onChanged (${docs.length} docs):\n` + printDocs(docs));
+            for (const doc of docs) {
+                if (isLikeC4LangiumDocument(doc)) {
+                    delete doc.c4fqns;
+                    delete doc.c4Elements;
+                    delete doc.c4Specification;
+                    delete doc.c4Relations;
+                    delete doc.c4Views;
+                }
+            }
+        });
         services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, (docs, _cancelToken) => {
+            logger.debug(`[FqnIndex] onIndexedContent ${docs.length}:\n` + printDocs(docs));
             for (const doc of docs) {
                 if (isLikeC4LangiumDocument(doc)) {
                     try {
                         computeDocumentFqn(doc, services);
                     }
                     catch (e) {
-                        logger.error(e);
+                        logError(e);
                     }
                 }
             }
@@ -28,17 +52,26 @@ export class FqnIndex {
         return this.langiumDocuments.all.filter(isFqnIndexedDocument);
     }
     entries() {
-        return this.documents().flatMap(doc => doc.c4fqns.entries().map(([fqn, path]) => ({ fqn, path, doc })));
+        return this.documents().flatMap(doc => doc.c4fqns
+            .entries()
+            .map(([fqn, entry]) => {
+            const el = entry.el.deref();
+            if (el) {
+                return { ...entry, fqn, el, doc };
+            }
+            return null;
+        })
+            .nonNullable());
     }
     getFqn(el) {
-        return ElementOps.readId(el) ?? null;
+        return el.fqn ?? ElementOps.readId(el) ?? null;
         // if (fqn) {
         //   const doc = getDocument(el)
         //   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}`)
+        //   logError(`Clean cached FQN ${fqn} at ${path}`)
         //   ElementOps.writeId(el, null)
         //   fqn = null
         // }
@@ -46,31 +79,28 @@ export class FqnIndex {
     }
     byFqn(fqn) {
         return this.documents().flatMap(doc => {
-            return doc.c4fqns.get(fqn).map(path => ({ path, doc }));
+            return doc.c4fqns.get(fqn).flatMap(entry => {
+                const el = entry.el.deref();
+                if (el) {
+                    return [{ fqn, el, doc, path: entry.path, name: entry.name }];
+                }
+                return [];
+            });
         });
     }
     directChildrenOf(parent) {
-        return new StreamImpl(() => {
+        return stream([parent]).flatMap(_parent => {
             const children = this.entries()
-                .filter(e => parentFqn(e.fqn) === parent)
-                .map((e) => {
-                const name = nameFromFqn(e.fqn);
-                const entry = { ...e, name };
-                return [name, entry];
-            })
+                .filter(e => parentFqn(e.fqn) === _parent)
+                .map((entry) => [entry.name, entry])
                 .toArray();
             if (children.length === 0) {
-                return null;
+                return [];
             }
             return new MultiMap(children)
                 .entriesGroupedByKey()
                 .flatMap(([_name, descrs]) => (descrs.length === 1 ? descrs : []))
                 .iterator();
-        }, iterator => {
-            if (iterator) {
-                return iterator.next();
-            }
-            return DONE_RESULT;
         });
     }
     /**

package/dist/model/index.d.ts

@@ -2,4 +2,5 @@ export * from './fqn-computation';
 export * from './fqn-index';
 export * from './model-builder';
 export * from './model-locator';
+export * from './model-parser';
 //# sourceMappingURL=index.d.ts.map

package/dist/model/index.js

@@ -2,4 +2,5 @@ export * from './fqn-computation';
 export * from './fqn-index';
 export * from './model-builder';
 export * from './model-locator';
+export * from './model-parser';
 //# sourceMappingURL=index.js.map

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

@@ -1,30 +1,13 @@
-import type * as c4 from '@likec4/core/types';
-import { ast } from '../ast';
-import type { LikeC4LangiumDocument } from '../ast';
+import { type c4 } from '@likec4/core';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4ModelBuilder {
     private services;
-    private fqnIndex;
     private langiumDocuments;
     private readonly cachedModel;
     constructor(services: LikeC4Services);
     private cleanCache;
     private documents;
     buildModel(): c4.LikeC4Model | null;
-    private _buildModel;
-    /**
-     * @returns if the document was changed
-     */
-    protected parseDocument(doc: LikeC4LangiumDocument): void;
-    private parseElement;
-    private parseRelation;
-    private parseElementExpression;
-    private parseExpression;
-    private parseViewRule;
-    private parseElementView;
-    protected resolveFqn(node: ast.Element | ast.ExtendElement): c4.Fqn;
-    private getAstNodePath;
-    private convertTags;
     private scheduledCb;
     private notifyClient;
 }