@likec4/language-server 0.6.1 → 0.6.2

package/dist/model/fqn-index.js

@@ -1,138 +0,0 @@
-import { DocumentState, DONE_RESULT, MultiMap, StreamImpl } from 'langium';
-import { ast, ElementOps } from '../ast';
-import { logger } from '../logger';
-import { parentFqn } from '@likec4/core/utils';
-import { Fqn } from '@likec4/core/types';
-import { strictElementRefFqn } from '../elementRef';
-export class FqnIndex {
-    services;
-    // #fqnMap = new WeakMap<ast.Element, Fqn>()
-    #index = new MultiMap();
-    descriptions;
-    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);
-            }
-        });
-    }
-    get(el) {
-        let fqn = ElementOps.readId(el) ?? null;
-        // if ()
-        // let fqn = this.#fqnMap.get(el) ?? null
-        if (fqn && !this.#index.has(fqn)) {
-            const path = this.services.workspace.AstNodeLocator.getAstNodePath(el);
-            logger.error(`Clean cached FQN ${fqn} at ${path}`);
-            // this.#fqnMap.delete(el)
-            fqn = null;
-        }
-        return fqn;
-    }
-    byFqn(fqn) {
-        return this.#index.get(fqn);
-    }
-    directChildrenOf(parent) {
-        return this.#index
-            .entriesGroupedByKey()
-            .flatMap(([fqn, descrs]) => (descrs.length === 1 && parentFqn(fqn) === parent ? descrs : []));
-    }
-    uniqueDescedants(parent) {
-        return new StreamImpl(() => {
-            const prefix = `${parent}.`;
-            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]);
-                    }
-                    else {
-                        descedants.push([fqn, desc]);
-                    }
-                }
-            });
-            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);
-                }
-            }
-            return nested
-                .entriesGroupedByKey()
-                .flatMap(([_name, descrs]) => (descrs.length === 1 ? descrs : []))
-                .iterator();
-        }, iterator => {
-            if (iterator) {
-                return iterator.next();
-            }
-            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);
-        }
-    }
-}

package/dist/model/index.d.ts

@@ -1,3 +0,0 @@
-export * from './fqn-index';
-export * from './model-builder';
-export * from './model-locator';

package/dist/model/index.js

@@ -1,3 +0,0 @@
-export * from './fqn-index';
-export * from './model-builder';
-export * from './model-locator';

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

@@ -1,26 +0,0 @@
-import type * as c4 from '@likec4/core/types';
-import { ast, type LikeC4LangiumDocument } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4ModelBuilder {
-    private services;
-    private fqnIndex;
-    private langiumDocuments;
-    constructor(services: LikeC4Services);
-    private get connection();
-    private documents;
-    buildModel(): c4.LikeC4Model | undefined;
-    /**
-     * @returns if the document was changed
-     */
-    protected parseDocument(doc: LikeC4LangiumDocument): boolean;
-    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 notifyClient;
-}

package/dist/model/model-builder.js

@@ -1,332 +0,0 @@
-import { computeViews } from '@likec4/core/compute-view';
-import { DefaultElementShape, DefaultThemeColor } from '@likec4/core/types';
-import { compareByFqnHierarchically, parentFqn } from '@likec4/core/utils';
-import { A, O, flow, pipe } from '@mobily/ts-belt';
-import { DocumentState, getDocument, interruptAndCheck } from 'langium';
-import objectHash from 'object-hash';
-import { clone, isNil, mergeDeepRight, omit, reduce } from 'rambdax';
-import invariant from 'tiny-invariant';
-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 { failExpectedNever } from '../utils';
-export class LikeC4ModelBuilder {
-    services;
-    fqnIndex;
-    langiumDocuments;
-    constructor(services) {
-        this.services = services;
-        this.fqnIndex = services.likec4.FqnIndex;
-        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Validated, async (docs, cancelToken) => {
-            let countOfChangedDocs = 0;
-            try {
-                for (const doc of docs) {
-                    await interruptAndCheck(cancelToken);
-                    try {
-                        if (isLikeC4LangiumDocument(doc) && this.parseDocument(doc)) {
-                            countOfChangedDocs++;
-                        }
-                    }
-                    catch (e) {
-                        logger.warn(`Error parsing document ${doc.uri.toString()}`);
-                    }
-                }
-            }
-            finally {
-                if (countOfChangedDocs > 0 && !cancelToken.isCancellationRequested) {
-                    await this.notifyClient();
-                }
-            }
-        });
-    }
-    get connection() {
-        return this.services.shared.lsp.Connection;
-    }
-    documents() {
-        return this.langiumDocuments.all.toArray().filter(isParsedLikeC4LangiumDocument);
-    }
-    buildModel() {
-        const docs = this.documents();
-        if (docs.length === 0) {
-            return;
-        }
-        try {
-            const c4Specification = reduce((acc, doc) => mergeDeepRight(acc, doc.c4Specification), {
-                kinds: {}
-            }, docs);
-            // const c4Specification = docs.reduce<ParsedAstSpecification>((acc, doc) => {
-            //   return mergeDeepRight(acc, doc.c4Specification)
-            // }, {
-            //   kinds: {}
-            // })
-            const toModelElement = (el) => {
-                const kind = c4Specification.kinds[el.kind];
-                if (kind) {
-                    return {
-                        ...(kind.shape !== DefaultElementShape ? { shape: kind.shape } : {}),
-                        ...(kind.color !== DefaultThemeColor ? { color: kind.color } : {}),
-                        ...omit(['astPath'], el)
-                    };
-                }
-                return null;
-            };
-            const toModelRelation = (rel) => {
-                return omit(['astPath'], rel);
-            };
-            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);
-                    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);
-                acc[el.id] = el;
-                return acc;
-            }));
-            const toModelView = (view) => {
-                let title = view.title;
-                if (!title && view.viewOf) {
-                    title = elements[view.viewOf]?.title;
-                }
-                return {
-                    ...omit(['astPath', 'rules', 'tite'], 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);
-                acc[v.id] = v;
-                return acc;
-            }));
-            return computeViews({
-                elements,
-                relations,
-                views
-            });
-        }
-        catch (e) {
-            logger.error(e);
-            return;
-        }
-    }
-    /**
-     * @returns if the document was changed
-     */
-    parseDocument(doc) {
-        const { elements, relations, views, specification } = cleanParsedModel(doc);
-        const spec = doc.parseResult.value.specification;
-        if (spec) {
-            for (const { kind, style } of spec.elementKinds) {
-                try {
-                    const styleProps = toElementStyle(style?.props);
-                    specification.kinds[kind.name] = {
-                        color: styleProps.color ?? DefaultThemeColor,
-                        shape: styleProps.shape ?? DefaultElementShape
-                    };
-                }
-                catch (e) {
-                    logger.warn(e);
-                }
-            }
-        }
-        for (const el of streamModel(doc)) {
-            if (ast.isElement(el)) {
-                try {
-                    elements.push(this.parseElement(el));
-                }
-                catch (e) {
-                    logger.warn(e);
-                }
-                continue;
-            }
-            if (ast.isRelation(el)) {
-                try {
-                    relations.push(this.parseRelation(el));
-                }
-                catch (e) {
-                    logger.warn(e);
-                }
-                continue;
-            }
-            failExpectedNever(el);
-        }
-        const docviews = doc.parseResult.value.views?.views;
-        if (docviews) {
-            for (const view of docviews) {
-                try {
-                    const v = this.parseElementView(view);
-                    ElementViewOps.writeId(view, v.id);
-                    views.push(v);
-                }
-                catch (e) {
-                    logger.warn(e);
-                }
-            }
-        }
-        const prevHash = doc.c4hash ?? '';
-        doc.c4hash = c4hash(doc);
-        return prevHash !== doc.c4hash;
-    }
-    parseElement(astNode) {
-        const id = this.resolveFqn(astNode);
-        invariant(astNode.kind.ref, 'Element kind is not resolved: ' + astNode.name);
-        const kind = astNode.kind.ref.name;
-        const tags = (astNode.body && this.convertTags(astNode.body)) ?? [];
-        const styleProps = astNode.body?.props.find(ast.isElementStyleProperty)?.props;
-        const { color, shape } = toElementStyle(styleProps);
-        const astPath = this.getAstNodePath(astNode);
-        let [title, description, technology] = astNode.props;
-        const bodyProps = astNode.body?.props.filter((p) => ast.isElementStringProperty(p)) ?? [];
-        title = title ?? bodyProps.find(p => p.key === 'title')?.value;
-        description = description ?? bodyProps.find(p => p.key === 'description')?.value;
-        technology = technology ?? bodyProps.find(p => p.key === 'technology')?.value;
-        return {
-            id,
-            kind,
-            astPath,
-            title: title ?? astNode.name,
-            ...(technology && { technology }),
-            ...(description && { description }),
-            ...(tags.length > 0 ? { tags } : {}),
-            ...(shape && shape !== DefaultElementShape ? { shape } : {}),
-            ...(color && color !== DefaultThemeColor ? { color } : {})
-        };
-    }
-    parseRelation(astNode) {
-        const coupling = resolveRelationPoints(astNode);
-        const target = this.resolveFqn(coupling.target);
-        const source = this.resolveFqn(coupling.source);
-        const hashdata = {
-            astPath: this.getAstNodePath(astNode),
-            source,
-            target
-        };
-        const id = objectHash(hashdata);
-        const title = astNode.title ?? astNode.definition?.props.find(p => p.key === 'title')?.value ?? '';
-        return {
-            id,
-            ...hashdata,
-            title
-        };
-    }
-    parseElementExpression(astNode) {
-        if (ast.isWildcardExpression(astNode)) {
-            return {
-                wildcard: true
-            };
-        }
-        if (ast.isElementRefExpression(astNode)) {
-            const element = elementRef(astNode.id);
-            invariant(element, 'Element not found ' + astNode.id.$cstNode?.text);
-            return {
-                element: this.resolveFqn(element),
-                isDescedants: astNode.isDescedants
-            };
-        }
-        failExpectedNever(astNode);
-    }
-    parseExpression(astNode) {
-        if (ast.isElementExpression(astNode)) {
-            return this.parseElementExpression(astNode);
-        }
-        if (ast.isIncomingExpression(astNode)) {
-            return {
-                incoming: this.parseElementExpression(astNode.target)
-            };
-        }
-        if (ast.isOutgoingExpression(astNode)) {
-            return {
-                outgoing: this.parseElementExpression(astNode.source)
-            };
-        }
-        if (ast.isInOutExpression(astNode)) {
-            return {
-                inout: this.parseElementExpression(astNode.inout.target)
-            };
-        }
-        if (ast.isRelationExpression(astNode)) {
-            return {
-                source: this.parseElementExpression(astNode.source),
-                target: this.parseElementExpression(astNode.target)
-            };
-        }
-        failExpectedNever(astNode);
-    }
-    parseViewRule(astRule) {
-        if (ast.isViewRuleExpression(astRule)) {
-            const exprs = astRule.expressions.map(n => this.parseExpression(n));
-            return {
-                isInclude: astRule.isInclude,
-                exprs
-            };
-        }
-        if (ast.isViewRuleStyle(astRule)) {
-            const styleProps = toElementStyle(astRule.props);
-            return {
-                targets: astRule.targets.map(n => this.parseElementExpression(n)),
-                style: {
-                    ...styleProps
-                }
-            };
-        }
-        if (ast.isViewRuleAutoLayout(astRule)) {
-            return {
-                autoLayout: toAutoLayout(astRule.direction)
-            };
-        }
-        failExpectedNever(astRule);
-    }
-    parseElementView(astNode) {
-        const viewOfEl = astNode.viewOf && elementRef(astNode.viewOf);
-        const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
-        const astPath = this.getAstNodePath(astNode);
-        let id = astNode.name;
-        if (!id) {
-            const doc = getDocument(astNode).uri.toString();
-            id = objectHash({
-                doc,
-                astPath,
-                viewOf: viewOf ?? null
-            });
-        }
-        const title = astNode.properties.find(p => p.key === 'title')?.value;
-        const description = astNode.properties.find(p => p.key === 'description')?.value;
-        return {
-            id,
-            astPath,
-            ...(viewOf && { viewOf }),
-            ...(title && { title }),
-            ...(description && { description }),
-            rules: astNode.rules.map(n => this.parseViewRule(n))
-        };
-    }
-    resolveFqn(node) {
-        if (ast.isExtendElement(node)) {
-            return strictElementRefFqn(node.element);
-        }
-        const fqn = this.fqnIndex.get(node);
-        invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
-        return fqn;
-    }
-    getAstNodePath(node) {
-        return this.services.workspace.AstNodeLocator.getAstNodePath(node);
-    }
-    convertTags(el) {
-        return el.tags?.value.map(tagRef => tagRef.ref?.name) ?? [];
-    }
-    async notifyClient() {
-        const connection = this.connection;
-        if (!connection) {
-            return;
-        }
-        logger.debug('Send onDidChangeModel');
-        await connection.sendNotification(Rpc.onDidChangeModel);
-    }
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/model/model-builder.spec.js

@@ -1,141 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createTestServices } from '../test';
-import { keys } from 'rambdax';
-describe('LikeC4ModelBuilder', () => {
-    it('builds model', async () => {
-        const { validate, buildModel } = createTestServices();
-        const { diagnostics } = await validate(`
-    specification {
-      element component
-      element user {
-        style {
-          shape: person
-        }
-      }
-      tag deprecated
-    }
-    model {
-      user client {
-        -> frontend
-      }
-      component system {
-        backend = component 'Backend' {
-          technology 'NodeJS'
-
-          style {
-            color secondary
-          }
-        }
-        component frontend {
-          #deprecated
-          description 'Frontend description'
-
-          style {
-            color: muted
-            shape: browser
-          }
-
-          -> backend 'requests'
-        }
-      }
-    }
-    `);
-        expect(diagnostics).toHaveLength(0);
-        const model = await buildModel();
-        expect(model).toBeDefined();
-        expect(model.elements).toMatchObject({
-            client: {
-                kind: 'user',
-                shape: 'person'
-            },
-            'system.backend': {
-                color: 'secondary',
-                title: 'Backend',
-                technology: 'NodeJS'
-            },
-            'system.frontend': {
-                color: 'muted',
-                shape: 'browser',
-                description: 'Frontend description'
-            }
-        });
-        expect(model.elements['client']).not.toHaveProperty('color');
-        expect(model.elements['system']).not.toHaveProperty('color');
-        expect(model.elements['system']).not.toHaveProperty('shape');
-        expect(model.elements['system.backend']).toHaveProperty('color', 'secondary');
-        expect(model.elements['system.backend']).not.toHaveProperty('description');
-        expect(model).toMatchSnapshot();
-    });
-    it('builds model with extend', async () => {
-        const { parse, validateAll, buildModel } = createTestServices();
-        await parse(`
-    specification {
-      element component
-      element user
-      tag deprecated
-    }
-    model {
-      user client
-      component system {
-        backend = component
-        component frontend
-      }
-    }
-    `);
-        await parse(`
-    model {
-      extend system.backend {
-        component api
-      }
-      system.frontend -> api 'requests'
-      client -> system.frontend {
-        title 'opens'
-      }
-    }
-    views {
-      view index {
-        title 'Index'
-        include *
-      }
-
-      view v1 of api {
-        include *
-        autoLayout LeftRight
-      }
-
-      view of system.frontend {
-        include *
-      }
-    }
-    `);
-        const { errors } = await validateAll();
-        expect(errors).toEqual([]);
-        const model = await buildModel();
-        expect(model).toBeDefined();
-        expect(model.elements).toMatchObject({
-            client: {
-                kind: 'user'
-            },
-            'system.backend.api': {
-                kind: 'component'
-            }
-        });
-        expect(keys(model.relations)).toHaveLength(2);
-        expect(keys(model.views)).toHaveLength(3);
-        expect(model.views).toMatchObject({
-            index: {
-                id: 'index',
-                title: 'Index',
-                autoLayout: 'TB'
-            },
-            v1: {
-                id: 'v1',
-                viewOf: 'system.backend.api',
-                title: 'api',
-                autoLayout: 'LR'
-            }
-        });
-        expect(model.views['index']).not.toHaveProperty('viewOf');
-        expect(model).toMatchSnapshot();
-    });
-});

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

@@ -1,16 +0,0 @@
-import type * as c4 from '@likec4/core/types';
-import type { Location } from 'vscode-languageserver-protocol';
-import type { ParsedAstElement } from '../ast';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4ModelLocator {
-    private services;
-    private fqnIndex;
-    private langiumDocuments;
-    constructor(services: LikeC4Services);
-    private documents;
-    getParsedElement(astNode: ast.Element): ParsedAstElement | null;
-    locateElement(fqn: c4.Fqn, property?: string): Location | null;
-    locateRelation(relationId: c4.RelationID): Location | null;
-    locateView(viewId: c4.ViewID): Location | null;
-}