@likec4/language-server 1.47.0 → 1.48.0

package/dist/model/model-locator.js

@@ -1,240 +0,0 @@
-import { splitGlobalFqn } from '@likec4/core';
-import { ifilter, invariant, toArray } from '@likec4/core/utils';
-import { loggable } from '@likec4/log';
-import { AstUtils, DocumentState, GrammarUtils } from 'langium';
-import { flatMap, isString, pipe } from 'remeda';
-import { URI } from 'vscode-uri';
-import { ast, isLikeC4LangiumDocument } from '../ast';
-import { logger as serverLogger } from '../logger';
-import { projectIdFrom } from '../utils';
-import { MergedSpecification } from './builder/MergedSpecification';
-const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
-const { getDocument, streamAllContents } = AstUtils;
-const logger = serverLogger.getChild('ModelLocator');
-export class LikeC4ModelLocator {
-    services;
-    fqnIndex;
-    deploymentsIndex;
-    langiumDocuments;
-    parser;
-    projects;
-    constructor(services) {
-        this.services = services;
-        this.fqnIndex = services.likec4.FqnIndex;
-        this.deploymentsIndex = services.likec4.DeploymentsIndex;
-        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-        this.parser = services.likec4.ModelParser;
-        this.projects = services.shared.workspace.ProjectsManager;
-    }
-    documents(projectId) {
-        return this.parser.documents(projectId);
-    }
-    // public getParsedElement(astNodeOrFqn: ast.Element): ParsedAstElement | null
-    // public getParsedElement(astNodeOrFqn: c4.Fqn, projectId?: c4.ProjectId): ParsedAstElement | null
-    getParsedElement(...args) {
-        let astNodeOrFqn;
-        let projectId;
-        if (args.length === 2) {
-            astNodeOrFqn = args[0];
-            projectId = args[1];
-        }
-        else {
-            astNodeOrFqn = args[0];
-            projectId = isString(astNodeOrFqn) ? this.projects.ensureProjectId() : projectIdFrom(astNodeOrFqn);
-        }
-        if (isString(astNodeOrFqn)) {
-            const fqn = astNodeOrFqn;
-            const entry = this.fqnIndex.byFqn(projectId, fqn).head();
-            if (!entry) {
-                return null;
-            }
-            const doc = this.langiumDocuments.getDocument(entry.documentUri);
-            if (!doc) {
-                return null;
-            }
-            return this.parser.parse(doc).c4Elements.find(e => e.id === fqn) ?? null;
-        }
-        const fqn = this.fqnIndex.getFqn(astNodeOrFqn);
-        const doc = this.parser.parse(getDocument(astNodeOrFqn));
-        return doc.c4Elements.find(e => e.id === fqn) ?? null;
-    }
-    locateElement(fqn, projectId) {
-        let [_projectId, _fqn] = splitGlobalFqn(fqn);
-        _projectId ??= this.projects.ensureProjectId(projectId);
-        const entry = this.fqnIndex.byFqn(_projectId, _fqn).head();
-        const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
-        if (!entry || !docsegment) {
-            return null;
-        }
-        return {
-            uri: entry.documentUri.toString(),
-            range: docsegment.range,
-        };
-    }
-    locateDeploymentElement(deploymentFqn, projectId) {
-        // let [_projectId, _fqn] = splitGlobalFqn(fqn)
-        const _projectId = this.projects.ensureProjectId(projectId);
-        // TODO: remove this cast to Fqn
-        const fqn = deploymentFqn;
-        const entry = this.deploymentsIndex.byFqn(_projectId, fqn).head();
-        const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
-        if (!entry || !docsegment) {
-            return null;
-        }
-        return {
-            uri: entry.documentUri.toString(),
-            range: docsegment.range,
-        };
-    }
-    locateRelation(relationId, projectId) {
-        const project = this.projects.ensureProjectId(projectId);
-        for (const doc of this.documents(project)) {
-            const relation = doc.c4Relations.find(r => r.id === relationId)
-                ?? doc.c4DeploymentRelations.find(r => r.id === relationId);
-            if (!relation) {
-                continue;
-            }
-            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, relation.astPath);
-            if (!ast.isRelation(node) && !ast.isDeploymentRelation(node)) {
-                continue;
-            }
-            let targetNode = node.kind ? findNodeForProperty(node.$cstNode, 'kind') : undefined;
-            targetNode ??= node.dotKind ? findNodeForProperty(node.$cstNode, 'dotKind') : undefined;
-            targetNode ??= findNodeForKeyword(node.$cstNode, '->');
-            targetNode ??= findNodeForProperty(node.$cstNode, 'title');
-            targetNode ??= findNodeForProperty(node.$cstNode, 'target');
-            targetNode ??= node.$cstNode;
-            if (!targetNode) {
-                continue;
-            }
-            return {
-                uri: doc.uri.toString(),
-                range: {
-                    start: targetNode.range.start,
-                    end: targetNode.range.start,
-                },
-            };
-        }
-        return null;
-    }
-    locateViewAst(viewId, projectId) {
-        const project = this.projects.ensureProjectId(projectId);
-        for (const doc of this.documents(project)) {
-            const view = doc.c4Views.find(r => r.id === viewId);
-            if (!view) {
-                continue;
-            }
-            const viewAst = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, view.astPath);
-            if (ast.isLikeC4View(viewAst)) {
-                return {
-                    doc,
-                    view,
-                    viewAst,
-                };
-            }
-        }
-        return null;
-    }
-    locateView(viewId, projectId) {
-        const res = this.locateViewAst(viewId, projectId);
-        if (!res) {
-            return null;
-        }
-        const node = res.viewAst;
-        let targetNode = node.name ? findNodeForProperty(node.$cstNode, 'name') : undefined;
-        targetNode ??= findNodeForKeyword(node.$cstNode, 'view');
-        targetNode ??= node.$cstNode;
-        if (!targetNode) {
-            return null;
-        }
-        return {
-            uri: res.doc.uri.toString(),
-            range: {
-                start: targetNode.range.start,
-                end: targetNode.range.start,
-            },
-        };
-    }
-    async locateDocumentTags(documentUri, cancelToken) {
-        const doc = this.langiumDocuments.getDocument(documentUri);
-        if (!doc || !isLikeC4LangiumDocument(doc)) {
-            return [];
-        }
-        if (doc.state < DocumentState.Validated) {
-            logger.debug(`Waiting for document ${doc.uri.path} to be Validated`);
-            await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
-        }
-        const projectId = projectIdFrom(doc);
-        logger.debug(`locate document tags for ${doc.uri.path} in project ${projectId}`);
-        try {
-            const tagSpecs = new MergedSpecification(this.documents(projectId).toArray()).tags;
-            logger.debug(`Assigned colors to tags`, { tagSpecs });
-            const tags = pipe(streamAllContents(doc.parseResult.value), ifilter(astNode => ast.isTag(astNode) || ast.isTagRef(astNode)), toArray(), flatMap(tagRef => {
-                let name;
-                let $cstNode;
-                try {
-                    if (ast.isTag(tagRef)) {
-                        name = tagRef.name;
-                        $cstNode = tagRef.$cstNode;
-                    }
-                    else {
-                        name = tagRef.tag.$refText;
-                        $cstNode = tagRef.tag.$refNode;
-                    }
-                    const specification = tagSpecs[name];
-                    invariant(specification, `Tag ${name} not found in merged specification`);
-                    invariant($cstNode, `Tag ${name} does not have a $cstNode`);
-                    return {
-                        name,
-                        color: specification.color,
-                        range: $cstNode.range,
-                        isSpecification: ast.isTag(tagRef),
-                    };
-                }
-                catch (err) {
-                    logger.warn(`Fail on tag ${name}`, { err });
-                    return [];
-                }
-            }));
-            logger.debug(`Found ${tags.length} tags in document ${doc.uri.path}`);
-            return tags;
-        }
-        catch (e) {
-            logger.warn(loggable(e));
-            return [];
-        }
-    }
-    locateDynamicViewStep(params) {
-        const { doc, viewAst } = this.locateViewAst(params.view, params.projectId) ?? {};
-        if (!doc || !viewAst) {
-            return null;
-        }
-        if (!ast.isDynamicView(viewAst) || !viewAst.body) {
-            logger.warn(`View ${params.view} is not a dynamic view`);
-            return null;
-        }
-        const astPath = this.services.workspace.AstNodeLocator.getAstNodePath(viewAst.body) + params.astPath;
-        const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, astPath);
-        if (!node || !ast.isDynamicViewStep(node)) {
-            logger.warn(`Failed to locate dynamic view step ${astPath} in view ${params.view}`);
-            return null;
-        }
-        let targetNode = node.kind ? findNodeForProperty(node.$cstNode, 'kind') : undefined;
-        targetNode ??= node.dotKind ? findNodeForProperty(node.$cstNode, 'dotKind') : undefined;
-        targetNode ??= findNodeForKeyword(node.$cstNode, '->');
-        targetNode ??= findNodeForKeyword(node.$cstNode, '<-');
-        targetNode ??= findNodeForProperty(node.$cstNode, 'title');
-        targetNode ??= findNodeForProperty(node.$cstNode, 'target');
-        targetNode ??= node.$cstNode;
-        if (!targetNode) {
-            return null;
-        }
-        return {
-            uri: doc.uri.toString(),
-            range: {
-                start: targetNode.range.start,
-                end: targetNode.range.start,
-            },
-        };
-    }
-}

package/dist/model/model-parser-where.d.ts

@@ -1,4 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { ast } from '../ast';
-export declare function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator;
-export declare function createBinaryOperator(operator: Lowercase<ast.WhereBinaryExpression['operator']>, left: c4.WhereOperator, right: c4.WhereOperator | null): c4.WhereOperator;

package/dist/model/model-parser-where.js

@@ -1,81 +0,0 @@
-import { invariant, isAndOperator, isNonEmptyArray, isOrOperator, nonexhaustive } from '@likec4/core';
-import { ast } from '../ast';
-const parseEquals = ({ operator, not }, value) => {
-    if (operator.startsWith('!=')) {
-        return {
-            neq: value,
-        };
-    }
-    if (operator.startsWith('=')) {
-        return {
-            eq: value,
-        };
-    }
-    return not ? { neq: value } : { eq: value };
-};
-function parseParticipant(astNode) {
-    if (!ast.isWhereRelationParticipantKind(astNode) && !ast.isWhereRelationParticipantTag(astNode)) {
-        return null;
-    }
-    return astNode.participant;
-}
-export function parseWhereClause(astNode) {
-    switch (true) {
-        case ast.isWhereTagEqual(astNode): {
-            const tag = astNode.value.tag.ref?.name;
-            const participant = parseParticipant(astNode);
-            invariant(tag, 'Expected tag name');
-            const tagOperator = { tag: parseEquals(astNode, tag) };
-            return participant ? { participant, operator: tagOperator } : tagOperator;
-        }
-        case ast.isWhereKindEqual(astNode): {
-            const kind = astNode.value?.ref?.name;
-            const participant = parseParticipant(astNode);
-            invariant(kind, 'Expected kind name');
-            const kindOperator = { kind: parseEquals(astNode, kind) };
-            return participant ? { participant, operator: kindOperator } : kindOperator;
-        }
-        case ast.isWhereElementNegation(astNode) || ast.isWhereRelationNegation(astNode): {
-            return {
-                not: parseWhereClause(astNode.value),
-            };
-        }
-        case ast.isWhereBinaryExpression(astNode): {
-            const left = parseWhereClause(astNode.left);
-            const right = parseWhereClause(astNode.right);
-            const operator = astNode.operator.toLowerCase();
-            return createBinaryOperator(operator, left, right);
-        }
-        default:
-            nonexhaustive(astNode);
-    }
-}
-export function createBinaryOperator(operator, left, right) {
-    if (right === null) {
-        return left;
-    }
-    switch (operator) {
-        case 'and': {
-            const operands = [
-                isAndOperator(left) ? left.and : left,
-                isAndOperator(right) ? right.and : right,
-            ].flat();
-            invariant(isNonEmptyArray(operands), 'Expected non-empty array');
-            return {
-                and: operands,
-            };
-        }
-        case 'or': {
-            const operands = [
-                isOrOperator(left) ? left.or : left,
-                isOrOperator(right) ? right.or : right,
-            ].flat();
-            invariant(isNonEmptyArray(operands), 'Expected non-empty array');
-            return {
-                or: operands,
-            };
-        }
-        default:
-            nonexhaustive(operator);
-    }
-}