@likec4/language-server 0.35.0 → 0.37.0

package/dist/logger.js

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { normalizeError, serializeError } from '@likec4/core';
+import { normalizeError } from '@likec4/core';
 /* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 let isSilent = false;
 export const logger = {
@@ -44,6 +44,7 @@ export function logWarnError(err) {
         logger.warn(err);
         return;
     }
-    logger.warn(serializeError(err).message);
+    const error = normalizeError(err);
+    logger.warn(`${error.name}: ${error.message}`);
 }
 //# sourceMappingURL=logger.js.map

package/dist/lsp/DocumentSymbolProvider.js

@@ -1,5 +1,5 @@
 import { findNodeForProperty } from 'langium';
-import { compact, isEmpty, map, pipe } from 'remeda';
+import { compact, concat, isEmpty, map, pipe } from 'remeda';
 import { SymbolKind } from 'vscode-languageserver-protocol';
 import { ast } from '../ast';
 import { logError } from '../logger';
@@ -68,7 +68,7 @@ export class LikeC4DocumentSymbolProvider {
         const specKeywordNode = findNodeForProperty(cstModel, 'name');
         if (!specKeywordNode)
             return [];
-        const specSymbols = pipe(astSpec.specs, map(nd => {
+        const specSymbols = pipe(concat(astSpec.elements, astSpec.tags), map(nd => {
             if (ast.isSpecificationElementKind(nd)) {
                 return getElementKindSymbol(nd);
             }

package/dist/lsp/SemanticTokenProvider.js

@@ -10,6 +10,14 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             type: SemanticTokenTypes.keyword,
             modifier: [SemanticTokenModifiers.defaultLibrary]
         });
+        if ('arr' in node) {
+            acceptor({
+                node,
+                property: 'arr',
+                type: SemanticTokenTypes.keyword,
+                modifier: [SemanticTokenModifiers.defaultLibrary]
+            });
+        }
         if (ast.isElementRef(node) || ast.isStrictElementRef(node)) {
             acceptor({
                 node,
@@ -18,21 +26,21 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             });
             return;
         }
-        if (ast.isWildcardExpression(node)) {
+        if (ast.isElementViewRef(node)) {
             acceptor({
                 node,
-                property: 'isWildcard',
+                property: 'view',
                 type: SemanticTokenTypes.variable
             });
             return;
         }
-        if ('arr' in node) {
+        if (ast.isWildcardExpression(node)) {
             acceptor({
                 node,
-                property: 'arr',
-                type: SemanticTokenTypes.keyword,
-                modifier: [SemanticTokenModifiers.defaultLibrary]
+                property: 'isWildcard',
+                type: SemanticTokenTypes.variable
             });
+            return;
         }
         // if (
         //   ast.isRelation(node) ||
@@ -197,13 +205,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
                 modifier: [SemanticTokenModifiers.declaration]
             });
         }
-        if (node.viewOf) {
-            acceptor({
-                node,
-                keyword: 'of',
-                type: SemanticTokenTypes.keyword
-            });
-        }
     }
 }
 //# sourceMappingURL=SemanticTokenProvider.js.map

package/dist/model/fqn-computation.js

@@ -2,7 +2,7 @@ import { AsFqn, nonexhaustive } from '@likec4/core';
 import { MultiMap } from 'langium';
 import { isEmpty, isNil } from 'remeda';
 import { ElementOps, ast } from '../ast';
-import { strictElementRefFqn } from '../elementRef';
+import { fqnElementRef } from '../elementRef';
 export function computeDocumentFqn(document, services) {
     const c4fqns = (document.c4fqns = new MultiMap());
     const { model } = document.parseResult.value;
@@ -19,7 +19,7 @@ export function computeDocumentFqn(document, services) {
         }
         if (ast.isExtendElement(el)) {
             if (!isNil(el.body) && !isEmpty(el.body.elements)) {
-                const fqn = strictElementRefFqn(el.element);
+                const fqn = fqnElementRef(el.element);
                 el.body.elements.forEach(child => traverseStack.push([child, fqn]));
             }
             continue;

package/dist/model/fqn-index.js

@@ -51,9 +51,10 @@ export class FqnIndex {
     documents() {
         return this.langiumDocuments.all.filter(isFqnIndexedDocument);
     }
-    entries() {
+    entries(filterByFqn = () => true) {
         return this.documents().flatMap(doc => doc.c4fqns
             .entries()
+            .filter(([fqn]) => filterByFqn(fqn))
             .map(([fqn, entry]) => {
             const el = entry.el.deref();
             if (el) {
@@ -90,8 +91,7 @@ export class FqnIndex {
     }
     directChildrenOf(parent) {
         return stream([parent]).flatMap(_parent => {
-            const children = this.entries()
-                .filter(e => parentFqn(e.fqn) === _parent)
+            const children = this.entries(fqn => parentFqn(fqn) === _parent)
                 .map((entry) => [entry.name, entry])
                 .toArray();
             if (children.length === 0) {
@@ -112,9 +112,7 @@ export class FqnIndex {
             const childrenNames = new Set();
             const descedants = [];
             const nested = new MultiMap();
-            this.entries()
-                .filter(e => e.fqn.startsWith(prefix))
-                .forEach(e => {
+            this.entries(f => f.startsWith(prefix)).forEach(e => {
                 const name = nameFromFqn(e.fqn);
                 const entry = { ...e, name };
                 // To keep direct children always

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

@@ -1,4 +1,4 @@
-import { type c4 } from '@likec4/core';
+import { type ViewID, type c4 } from '@likec4/core';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4ModelBuilder {
     private services;
@@ -7,7 +7,9 @@ export declare class LikeC4ModelBuilder {
     constructor(services: LikeC4Services);
     private cleanCache;
     private documents;
+    buildRawModel(): c4.LikeC4RawModel | null;
     buildModel(): c4.LikeC4Model | null;
+    computeView(viewId: ViewID): c4.ComputedView | null;
     private scheduledCb;
     private notifyClient;
 }

package/dist/model/model-builder.js

@@ -1,5 +1,4 @@
-import { ModelIndex, assignNavigateTo, compareByFqnHierarchically, computeView, parentFqn } from '@likec4/core';
-import { clone } from 'rambdax';
+import { ModelIndex, compareByFqnHierarchically, parentFqn, resolveRulesExtendedViews, computeView, assignNavigateTo, isStrictElementView } from '@likec4/core';
 import * as R from 'remeda';
 import { isValidLikeC4LangiumDocument } from '../ast';
 import { logError, logWarnError, logger } from '../logger';
@@ -58,42 +57,29 @@ function buildModel(docs) {
         return null;
     };
     const relations = R.pipe(R.flatMap(docs, d => d.c4Relations), R.map(toModelRelation), R.compact, R.mapToObj(r => [r.id, r]));
-    const modelIndex = ModelIndex.from({ elements, relations });
-    const toModelView = (view) => {
-        try {
-            // eslint-disable-next-line prefer-const
-            let { astPath, rules, title, description, tags, links, ...model } = view;
-            if (!title && view.viewOf) {
-                title = elements[view.viewOf]?.title;
-            }
-            if (!title && view.id === 'index') {
-                title = 'Landscape view';
-            }
-            const computeResult = computeView({
-                ...model,
-                title: title ?? null,
-                description: description ?? null,
-                tags: tags ?? null,
-                links: links ?? null,
-                rules: clone(rules)
-            }, modelIndex);
-            if (!computeResult.isSuccess) {
-                logWarnError(computeResult.error);
-                return null;
-            }
-            return computeResult.view;
+    const toElementView = (view) => {
+        // eslint-disable-next-line prefer-const
+        let { astPath, rules, title, description, tags, links, ...model } = view;
+        if (!title && 'viewOf' in view) {
+            title = elements[view.viewOf]?.title;
         }
-        catch (e) {
-            logError(e);
-            return null;
+        if (!title && view.id === 'index') {
+            title = 'Landscape view';
         }
+        return {
+            ...model,
+            title: title ?? null,
+            description: description ?? null,
+            tags: tags ?? null,
+            links: links ?? null,
+            rules
+        };
     };
-    const views = R.pipe(R.flatMap(docs, d => d.c4Views), R.map(toModelView), R.compact);
-    assignNavigateTo(views);
+    const views = R.pipe(R.flatMap(docs, d => d.c4Views), R.map(toElementView), R.compact, R.mapToObj(v => [v.id, v]));
     return {
         elements,
         relations,
-        views: R.mapToObj(views, v => [v.id, v])
+        views: resolveRulesExtendedViews(views)
     };
 }
 export class LikeC4ModelBuilder {
@@ -114,7 +100,7 @@ export class LikeC4ModelBuilder {
     documents() {
         return this.langiumDocuments.all.filter(isValidLikeC4LangiumDocument).toArray();
     }
-    buildModel() {
+    buildRawModel() {
         if ('last' in this.cachedModel) {
             logger.debug('[ModelBuilder] returning cached model');
             return this.cachedModel.last;
@@ -133,6 +119,43 @@ export class LikeC4ModelBuilder {
             return null;
         }
     }
+    buildModel() {
+        const model = this.buildRawModel();
+        if (!model) {
+            return null;
+        }
+        const index = ModelIndex.from(model);
+        const views = R.pipe(R.values(model.views), R.map(view => computeView(view, index).view), R.compact);
+        assignNavigateTo(views);
+        return {
+            elements: model.elements,
+            relations: model.relations,
+            views: R.mapToObj(views, v => [v.id, v])
+        };
+    }
+    computeView(viewId) {
+        const model = this.buildRawModel();
+        const view = model?.views[viewId];
+        if (!view) {
+            logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
+            return null;
+        }
+        const result = computeView(view, ModelIndex.from(model));
+        if (!result.isSuccess) {
+            logError(result.error);
+            return null;
+        }
+        const allElementViews = R.values(model.views).filter((v) => isStrictElementView(v) && v.id !== viewId);
+        const computedView = result.view;
+        computedView.nodes.forEach(node => {
+            // find first element view that is not the current one
+            const navigateTo = R.find(allElementViews, v => v.viewOf === node.id);
+            if (navigateTo) {
+                node.navigateTo = navigateTo.id;
+            }
+        });
+        return computedView;
+    }
     scheduledCb = null;
     notifyClient() {
         const connection = this.services.shared.lsp.Connection;

package/dist/model/model-locator.js

@@ -91,7 +91,7 @@ export class LikeC4ModelLocator {
             if (node.name) {
                 targetNode = findNodeForProperty(node.$cstNode, 'name') ?? targetNode;
             }
-            else if (node.viewOf) {
+            else if ('viewOf' in node) {
                 targetNode = findNodeForProperty(node.$cstNode, 'viewOf') ?? targetNode;
             }
             if (!targetNode) {

package/dist/model/model-parser.js

@@ -4,7 +4,7 @@ import objectHash from 'object-hash';
 import stripIndent from 'strip-indent';
 import { Disposable } from 'vscode-languageserver-protocol';
 import { ElementViewOps, ast, cleanParsedModel, isLikeC4LangiumDocument, resolveRelationPoints, streamModel, toAutoLayout, toElementStyle, toElementStyleExcludeDefaults } from '../ast';
-import { elementRef, strictElementRefFqn } from '../elementRef';
+import { elementRef, fqnElementRef } from '../elementRef';
 import { logError, logWarnError, logger } from '../logger';
 import { printDocs } from '../utils';
 export class LikeC4ModelParser {
@@ -46,7 +46,7 @@ export class LikeC4ModelParser {
     }
     async parseDocument(doc, cancelToken) {
         const { elements, relations, views, specification } = cleanParsedModel(doc);
-        const specs = doc.parseResult.value.specification?.specs.filter(ast.isSpecificationElementKind);
+        const specs = doc.parseResult.value.specification?.elements;
         if (specs) {
             for (const { kind, style } of specs) {
                 if (kind.name in specification.kinds) {
@@ -226,31 +226,29 @@ export class LikeC4ModelParser {
         nonexhaustive(astRule);
     }
     parseElementView(astNode) {
-        const viewOfEl = astNode.viewOf && elementRef(astNode.viewOf);
-        const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
+        const body = astNode.body;
+        invariant(body, 'ElementView body is not defined');
         const astPath = this.getAstNodePath(astNode);
         let id = astNode.name;
         if (!id) {
             const doc = getDocument(astNode).uri.toString();
             id = objectHash({
                 doc,
-                astPath,
-                viewOf: viewOf ?? null
+                astPath
             });
         }
-        const title = astNode.props.find(p => p.key === 'title')?.value;
-        const description = astNode.props.find(p => p.key === 'description')?.value;
-        const tags = this.convertTags(astNode);
-        const links = astNode.props.filter(ast.isLinkProperty).map(p => p.value);
-        return {
-            id,
+        const title = body.props.find(p => p.key === 'title')?.value;
+        const description = body.props.find(p => p.key === 'description')?.value;
+        const tags = this.convertTags(body);
+        const links = body.props.filter(ast.isLinkProperty).map(p => p.value);
+        const basic = {
+            id: id,
             astPath,
-            ...(viewOf && { viewOf }),
             ...(title && { title }),
             ...(description && { description }),
             ...(tags && { tags }),
-            ...(links && isNonEmptyArray(links) && { links }),
-            rules: astNode.rules.flatMap(n => {
+            ...(isNonEmptyArray(links) && { links }),
+            rules: body.rules.flatMap(n => {
                 try {
                     return this.parseViewRule(n);
                 }
@@ -260,10 +258,28 @@ export class LikeC4ModelParser {
                 }
             })
         };
+        if ('viewOf' in astNode) {
+            const viewOfEl = elementRef(astNode.viewOf);
+            const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
+            invariant(viewOf, ' viewOf is not resolved: ' + astNode.$cstNode?.text);
+            return {
+                ...basic,
+                viewOf
+            };
+        }
+        if ('extends' in astNode) {
+            const extendsView = astNode.extends.view.ref;
+            invariant(extendsView?.name, 'view extends is not resolved: ' + astNode.$cstNode?.text);
+            return {
+                ...basic,
+                extends: extendsView.name
+            };
+        }
+        return basic;
     }
     resolveFqn(node) {
         if (ast.isExtendElement(node)) {
-            return strictElementRefFqn(node.element);
+            return fqnElementRef(node.element);
         }
         const fqn = this.fqnIndex.getFqn(node);
         invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);

package/dist/protocol.d.ts

@@ -1,6 +1,6 @@
-import type { Fqn, LikeC4Model, RelationID, ViewID } from '@likec4/core';
+import type { ComputedView, Fqn, LikeC4Model, LikeC4RawModel, RelationID, ViewID } from '@likec4/core';
 import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
-import { NotificationType, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
 interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
@@ -18,6 +18,14 @@ export declare const Rpc: {
     readonly fetchModel: RequestType0<{
         model: LikeC4Model | null;
     }, void>;
+    readonly fetchRawModel: RequestType0<{
+        rawmodel: LikeC4RawModel | null;
+    }, void>;
+    readonly computeView: RequestType<{
+        viewId: ViewID;
+    }, {
+        view: ComputedView | null;
+    }, void>;
     readonly rebuild: RequestType0<{
         docs: DocumentUri[];
     }, void>;

package/dist/protocol.js

@@ -1,9 +1,11 @@
-import { NotificationType, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
 //#region From server
 const onDidChangeModel = new NotificationType('likec4/onDidChangeModel');
 //#endregion
 //#region To server
+const fetchRawModel = new RequestType0('likec4/fetchRaw');
 const fetchModel = new RequestType0('likec4/fetchModel');
+const computeView = new RequestType('likec4/computeView');
 const rebuild = new RequestType0('likec4/rebuildModel');
 const buildDocuments = new RequestType('likec4/buildDocuments');
 export const locate = new RequestType('likec4/locate');
@@ -11,6 +13,8 @@ export const locate = new RequestType('likec4/locate');
 export const Rpc = {
     onDidChangeModel,
     fetchModel,
+    fetchRawModel,
+    computeView,
     rebuild,
     buildDocuments,
     locate

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

@@ -1,11 +1,8 @@
 import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
 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>;

package/dist/references/scope-computation.js

@@ -1,32 +1,21 @@
 import { DefaultScopeComputation, MultiMap } from 'langium';
-import { ast } from '../ast';
 import { isEmpty } from 'remeda';
-import { nonexhaustive } from '@likec4/core';
+import { ast } from '../ast';
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
-    services;
-    constructor(services) {
-        super(services);
-        this.services = services;
-    }
     computeExports(document, _cancelToken) {
         const { specification, model, views } = document.parseResult.value;
         const docExports = [];
-        if (specification && specification.specs.length > 0) {
-            for (const spec of specification.specs) {
-                if (ast.isSpecificationElementKind(spec)) {
-                    if (spec.kind && !isEmpty(spec.kind.name)) {
-                        docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
-                    }
-                    continue;
+        if (specification) {
+            for (const spec of specification.elements) {
+                if (spec.kind && !isEmpty(spec.kind.name)) {
+                    docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
                 }
-                if (ast.isSpecificationTag(spec)) {
-                    if (spec.tag && !isEmpty(spec.tag.name)) {
-                        docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
-                        docExports.push(this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document));
-                    }
-                    continue;
+            }
+            for (const spec of specification.tags) {
+                if (spec.tag && !isEmpty(spec.tag.name)) {
+                    docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
+                    docExports.push(this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document));
                 }
-                nonexhaustive(spec);
             }
         }
         // Only root model elements are exported

package/dist/references/scope-provider.js

@@ -1,6 +1,6 @@
 import { DONE_RESULT, DefaultScopeProvider, EMPTY_STREAM, StreamImpl, StreamScope, getDocument, stream, findNodeForProperty, toDocumentSegment } from 'langium';
 import { ast } from '../ast';
-import { elementRef, isElementRefHead, parentStrictElementRef } from '../elementRef';
+import { elementRef, isElementRefHead, parentFqnElementRef } from '../elementRef';
 import { logError } from '../logger';
 function toAstNodeDescription(entry) {
     const $cstNode = findNodeForProperty(entry.el.$cstNode, 'name');
@@ -52,11 +52,17 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     scopeExtendElement(extend) {
         return this.uniqueDescedants(() => elementRef(extend.element));
     }
-    scopeElementView({ viewOf }) {
-        if (!viewOf) {
-            return EMPTY_STREAM;
+    scopeElementView({ viewOf, extends: ext }) {
+        if (ext) {
+            return stream([ext]).flatMap(v => {
+                const view = v.view.ref;
+                return view ? this.scopeElementView(view) : EMPTY_STREAM;
+            });
         }
-        return this.uniqueDescedants(() => elementRef(viewOf));
+        if (viewOf) {
+            return this.uniqueDescedants(() => elementRef(viewOf));
+        }
+        return EMPTY_STREAM;
     }
     getScope(context) {
         const referenceType = this.reflection.getReferenceType(context);
@@ -68,7 +74,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
                     if (isElementRefHead(container)) {
                         return this.getGlobalScope(referenceType);
                     }
-                    const parent = parentStrictElementRef(container);
+                    const parent = parentFqnElementRef(container);
                     return new StreamScope(this.directChildrenOf(parent));
                 }
                 if (ast.isElementRef(container) && !isElementRefHead(container)) {
@@ -102,7 +108,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
                     if (ast.isExtendElementBody(container)) {
                         scopes.push(this.scopeExtendElement(container.$container));
                     }
-                    if (ast.isViewRule(container)) {
+                    if (ast.isElementViewBody(container)) {
                         scopes.push(this.scopeElementView(container.$container));
                     }
                 }

package/dist/registerProtocolHandlers.js

@@ -22,6 +22,22 @@ export function registerProtocolHandlers(services) {
         }
         return Promise.resolve({ model });
     });
+    connection.onRequest(Rpc.fetchRawModel, async (_cancelToken) => {
+        let rawmodel;
+        try {
+            rawmodel = modelBuilder.buildRawModel() ?? null;
+        }
+        catch (e) {
+            rawmodel = null;
+            logError(e);
+        }
+        return Promise.resolve({ rawmodel });
+    });
+    connection.onRequest(Rpc.computeView, ({ viewId }) => {
+        return {
+            view: modelBuilder.computeView(viewId)
+        };
+    });
     connection.onRequest(Rpc.rebuild, async (cancelToken) => {
         const changed = LangiumDocuments.all
             .map(d => {

package/dist/validation/view.js

@@ -2,6 +2,9 @@ import { ast } from '../ast';
 export const viewChecks = (services) => {
     const index = services.shared.workspace.IndexManager;
     return (el, accept) => {
+        if (el.extends) {
+            // TODO: circular dependency check
+        }
         if (!el.name) {
             return;
         }

package/package.json

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