@likec4/language-server 0.6.0 → 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 '../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(astNode) {
-        if (ast.isViewRuleExpression(astNode)) {
-            const exprs = astNode.expressions.map(n => this.parseExpression(n));
-            return {
-                isInclude: astNode.isInclude,
-                exprs
-            };
-        }
-        if (ast.isViewRuleStyle(astNode)) {
-            const styleProps = toElementStyle(astNode.props);
-            return {
-                targets: astNode.targets.map(n => this.parseElementExpression(n)),
-                style: {
-                    ...styleProps
-                }
-            };
-        }
-        if (ast.isViewRuleAutoLayout(astNode)) {
-            return {
-                autoLayout: toAutoLayout(astNode.direction)
-            };
-        }
-        failExpectedNever(astNode);
-    }
-    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, null);
-    }
-}

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;
-}

package/dist/model/model-locator.js

@@ -1,108 +0,0 @@
-import { getDocument } from 'langium';
-import { findNodeForKeyword, findNodeForProperty } from 'langium';
-import { head } from 'rambdax';
-import { ast, isParsedLikeC4LangiumDocument } from '../ast';
-export class LikeC4ModelLocator {
-    services;
-    fqnIndex;
-    langiumDocuments;
-    constructor(services) {
-        this.services = services;
-        this.fqnIndex = services.likec4.FqnIndex;
-        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-    }
-    documents() {
-        return this.langiumDocuments.all.toArray().filter(isParsedLikeC4LangiumDocument);
-    }
-    getParsedElement(astNode) {
-        const doc = getDocument(astNode);
-        if (!isParsedLikeC4LangiumDocument(doc)) {
-            return null;
-        }
-        const fqn = this.fqnIndex.get(astNode);
-        if (!fqn)
-            return null;
-        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
-        };
-    }
-    locateRelation(relationId) {
-        for (const doc of this.documents()) {
-            const relation = doc.c4Relations.find(r => r.id === relationId);
-            if (!relation) {
-                continue;
-            }
-            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, relation.astPath);
-            if (!ast.isRelation(node)) {
-                continue;
-            }
-            if (node.title) {
-                const targetNode = findNodeForProperty(node.$cstNode, 'title');
-                if (targetNode) {
-                    return {
-                        uri: doc.uri.toString(),
-                        range: {
-                            start: targetNode.range.start,
-                            end: targetNode.range.start
-                        }
-                    };
-                }
-            }
-            const targetNode = findNodeForKeyword(node.$cstNode, '->');
-            if (!targetNode) {
-                return null;
-            }
-            return {
-                uri: doc.uri.toString(),
-                range: {
-                    start: targetNode.range.end,
-                    end: targetNode.range.end
-                }
-            };
-        }
-        return null;
-    }
-    locateView(viewId) {
-        for (const doc of this.documents()) {
-            const view = doc.c4Views.find(r => r.id === viewId);
-            if (!view) {
-                continue;
-            }
-            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, view.astPath);
-            if (!ast.isElementView(node)) {
-                continue;
-            }
-            let targetNode = node.$cstNode;
-            if (node.name) {
-                targetNode = findNodeForProperty(node.$cstNode, 'name') ?? targetNode;
-            }
-            else if (node.viewOf) {
-                targetNode = findNodeForProperty(node.$cstNode, 'viewOf') ?? targetNode;
-            }
-            if (!targetNode) {
-                return null;
-            }
-            return {
-                uri: doc.uri.toString(),
-                range: {
-                    start: targetNode.range.start,
-                    end: targetNode.range.start
-                }
-            };
-        }
-        return null;
-    }
-}

package/dist/module.d.ts

@@ -1,18 +0,0 @@
-import type { DefaultSharedModuleContext, LangiumServices, LangiumSharedServices, Module, PartialLangiumServices } from 'langium';
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator } from './model';
-/**
- * Declaration of custom services - add your own service classes here.
- */
-export interface LikeC4AddedServices {
-    likec4: {
-        FqnIndex: FqnIndex;
-        ModelBuilder: LikeC4ModelBuilder;
-        ModelLocator: LikeC4ModelLocator;
-    };
-}
-export type LikeC4Services = LangiumServices & LikeC4AddedServices;
-export declare const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
-export declare function createLanguageServices(context: DefaultSharedModuleContext): {
-    shared: LangiumSharedServices;
-    likec4: LikeC4Services;
-};