@likec4/language-server 0.29.0 → 0.30.0

package/dist/model/fqn-computation.js

@@ -1,11 +1,10 @@
-import { failExpectedNever } from '@likec4/core';
-import { Fqn } from '@likec4/core/types';
+import { failExpectedNever, AsFqn } from '@likec4/core';
 import { MultiMap } from 'langium';
 import { isEmpty, isNil } from 'remeda';
 import { ElementOps, ast } from '../ast';
 import { strictElementRefFqn } from '../elementRef';
 export function computeDocumentFqn(document, services) {
-    const c4fqns = document.c4fqns = new MultiMap();
+    const c4fqns = (document.c4fqns = new MultiMap());
     const { model } = document.parseResult.value;
     if (!model?.elements) {
         return;
@@ -26,7 +25,7 @@ export function computeDocumentFqn(document, services) {
             continue;
         }
         if (ast.isElement(el)) {
-            const fqn = Fqn(el.name, parent);
+            const fqn = AsFqn(el.name, parent);
             const path = locator.getAstNodePath(el);
             c4fqns.add(fqn, path);
             ElementOps.writeId(el, fqn);

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

@@ -1,6 +1,5 @@
-import type { Fqn } from '@likec4/core/types';
-import type { LangiumDocument, LangiumDocuments } from 'langium';
-import { StreamImpl } from 'langium';
+import type { Fqn } from '@likec4/core';
+import type { LangiumDocument, LangiumDocuments, Stream } from 'langium';
 import type { ast } from '../ast';
 import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
@@ -15,18 +14,20 @@ export interface FqnIndexEntry {
     path: string;
 }
 export declare class FqnIndex {
-    private services;
     protected langiumDocuments: LangiumDocuments;
     constructor(services: LikeC4Services);
     private documents;
     private entries;
-    get(el: ast.Element): Fqn | null;
-    byFqn(fqn: Fqn): import("langium").Stream<{
+    getFqn(el: ast.Element): Fqn | null;
+    byFqn(fqn: Fqn): Stream<{
         path: string;
-        doc: FqnIndexedDocument;
+        doc: LikeC4LangiumDocument;
     }>;
-    directChildrenOf(parent: Fqn): StreamImpl<IterableIterator<FqnIndexEntry> | null, FqnIndexEntry>;
-    uniqueDescedants(parent: Fqn): StreamImpl<IterableIterator<FqnIndexEntry> | null, 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,17 +1,15 @@
-import { nameFromFqn, parentFqn } from '@likec4/core/utils';
+import { nameFromFqn, parentFqn } from '@likec4/core';
 import { DONE_RESULT, DocumentState, MultiMap, StreamImpl } from 'langium';
 import { isNil } from 'remeda';
 import { ElementOps, isLikeC4LangiumDocument } from '../ast';
 import { logger } from '../logger';
 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 {
-    services;
     langiumDocuments;
     constructor(services) {
-        this.services = services;
         this.langiumDocuments = services.shared.workspace.LangiumDocuments;
         services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, (docs, _cancelToken) => {
             for (const doc of docs) {
@@ -32,7 +30,7 @@ export class FqnIndex {
     entries() {
         return this.documents().flatMap(doc => doc.c4fqns.entries().map(([fqn, path]) => ({ fqn, path, doc })));
     }
-    get(el) {
+    getFqn(el) {
         return ElementOps.readId(el) ?? null;
         // if (fqn) {
         //   const doc = getDocument(el)
@@ -75,6 +73,9 @@ export class FqnIndex {
             return DONE_RESULT;
         });
     }
+    /**
+     * Returns descedant elements with unique names in the scope
+     */
     uniqueDescedants(parent) {
         return new StreamImpl(() => {
             const prefix = `${parent}.`;
@@ -86,6 +87,7 @@ export class FqnIndex {
                 .forEach(e => {
                 const name = nameFromFqn(e.fqn);
                 const entry = { ...e, name };
+                // To keep direct children always
                 if (parentFqn(e.fqn) === parent) {
                     childrenNames.add(name);
                     nested.add(name, entry);

package/dist/model/model-builder.js

@@ -67,27 +67,32 @@ export class LikeC4ModelBuilder {
                 kinds: {}
             };
             R.forEach(R.map(docs, R.prop('c4Specification')), spec => Object.assign(c4Specification.kinds, spec.kinds));
-            const toModelElement = (el) => {
-                const kind = c4Specification.kinds[el.kind];
+            const toModelElement = ({ astPath, ...parsed }) => {
+                const kind = c4Specification.kinds[parsed.kind];
                 if (kind) {
-                    const { astPath, ...model } = el;
                     return {
-                        ...(kind.shape !== DefaultElementShape ? { shape: kind.shape } : {}),
-                        ...(kind.color !== DefaultThemeColor ? { color: kind.color } : {}),
-                        ...model
+                        shape: kind.shape,
+                        color: kind.color,
+                        description: null,
+                        technology: null,
+                        tags: [],
+                        ...parsed
                     };
                 }
                 return null;
             };
             const elements = R.pipe(R.flatMap(docs, d => d.c4Elements), R.map(toModelElement), R.compact, R.sort(compareByFqnHierarchically), R.reduce((acc, el) => {
                 const parent = parentFqn(el.id);
-                if (!parent || parent in acc) {
-                    if (el.id in acc) {
-                        logger.warn(`Duplicate element id: ${el.id}`);
-                        return acc;
-                    }
-                    acc[el.id] = el;
+                if (parent && R.isNil(acc[parent])) {
+                    logger.warn(`No parent found for ${el.id}`);
+                    return acc;
+                }
+                if (el.id in acc) {
+                    // should not happen, as validated
+                    logger.warn(`Duplicate element id: ${el.id}`);
+                    return acc;
                 }
+                acc[el.id] = el;
                 return acc;
             }, {}));
             const toModelRelation = ({ astPath, source, target, ...model }) => {
@@ -339,7 +344,7 @@ export class LikeC4ModelBuilder {
         if (ast.isExtendElement(node)) {
             return strictElementRefFqn(node.element);
         }
-        const fqn = this.fqnIndex.get(node);
+        const fqn = this.fqnIndex.getFqn(node);
         invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
         return fqn;
     }

package/dist/references/scope-provider.js

@@ -17,18 +17,15 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         this.fqnIndex = services.likec4.FqnIndex;
     }
     directChildrenOf(parent) {
-        return this.fqnIndex
-            .directChildrenOf(parent)
-            .map(toAstNodeDescription);
+        return this.fqnIndex.directChildrenOf(parent).map(toAstNodeDescription);
     }
+    // we need lazy resolving here
     uniqueDescedants(of) {
         return new StreamImpl(() => {
             const element = of();
-            const fqn = element && this.fqnIndex.get(element);
+            const fqn = element && this.fqnIndex.getFqn(element);
             if (fqn) {
-                return this.fqnIndex.uniqueDescedants(fqn)
-                    .map(toAstNodeDescription)
-                    .iterator();
+                return this.fqnIndex.uniqueDescedants(fqn).map(toAstNodeDescription).iterator();
             }
             return null;
         }, iterator => {
@@ -57,21 +54,21 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     getScope(context) {
         const referenceType = this.reflection.getReferenceType(context);
         try {
-            const node = context.container;
+            const container = context.container;
             // const path = this.services.workspace.AstNodeLocator.getAstNodePath(node)
             if (referenceType === ast.Element) {
-                if (ast.isStrictElementRef(node)) {
-                    if (isElementRefHead(node)) {
+                if (ast.isStrictElementRef(container)) {
+                    if (isElementRefHead(container)) {
                         return this.getGlobalScope(referenceType);
                     }
-                    const parent = parentStrictElementRef(node);
+                    const parent = parentStrictElementRef(container);
                     return new StreamScope(this.directChildrenOf(parent));
                 }
-                if (ast.isElementRef(node) && !isElementRefHead(node)) {
-                    return new StreamScope(this.scopeElementRef(node));
+                if (ast.isElementRef(container) && !isElementRefHead(container)) {
+                    return new StreamScope(this.scopeElementRef(container));
                 }
             }
-            return this.computeScope(node, referenceType);
+            return this.computeScope(container, referenceType);
         }
         catch (e) {
             // console.error(e)

package/dist/validation/element.js

@@ -1,7 +1,7 @@
 export const elementChecks = (services) => {
     const fqnIndex = services.likec4.FqnIndex;
     return (el, accept) => {
-        const fqn = fqnIndex.get(el);
+        const fqn = fqnIndex.getFqn(el);
         if (!fqn) {
             accept('error', 'Not indexed element', {
                 node: el,
@@ -11,12 +11,6 @@ export const elementChecks = (services) => {
         }
         const withSameFqn = fqnIndex.byFqn(fqn).limit(2).count();
         if (withSameFqn > 1) {
-            // console.error(withSameFqn.map(e => ({
-            //   fqn,
-            //   name: el.name,
-            //   path: e.path,
-            //   doc: e.doc.uri.toString()
-            // })))
             accept('error', `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`, {
                 node: el,
                 property: 'name'

package/dist/validation/relation.js

@@ -6,8 +6,8 @@ export const relationChecks = (services) => {
     return (el, accept) => {
         try {
             const coupling = resolveRelationPoints(el);
-            const target = fqnIndex.get(coupling.target);
-            const source = fqnIndex.get(coupling.source);
+            const target = fqnIndex.getFqn(coupling.target);
+            const source = fqnIndex.getFqn(coupling.source);
             if (!target || !source) {
                 if (!target) {
                     accept('error', 'Target not found', {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -59,7 +59,7 @@
     "test:watch": "run -T vitest"
   },
   "dependencies": {
-    "@likec4/core": "0.29.0",
+    "@likec4/core": "0.30.0",
     "langium": "^1.2.1",
     "nanoid": "^4.0.2",
     "object-hash": "^3.0.0",