@likec4/language-server 1.46.4 → 1.48.0

package/dist/model/parser/ModelParser.d.ts

@@ -1,71 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { FqnRef } from '@likec4/core/types';
-import { type ParsedAstElement, type ParsedAstExtend, type ParsedAstExtendRelation, type ParsedAstRelation, ast } from '../../ast';
-import type { WithExpressionV2 } from './FqnRefParser';
-export type WithModel = ReturnType<typeof ModelParser>;
-export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
-    new (...args: any[]): {
-        parseModel(): void;
-        parseElement(astNode: ast.Element): ParsedAstElement;
-        parseExtendElement(astNode: ast.ExtendElement): ParsedAstExtend | null;
-        parseExtendRelation(astNode: ast.ExtendRelation): ParsedAstExtendRelation | null;
-        _resolveRelationSource(node: ast.Relation): FqnRef.ModelRef | FqnRef.ImportRef;
-        parseRelation(astNode: ast.Relation): ParsedAstRelation;
-        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
-        parseExpressionV2(astNode: ast.ExpressionV2): c4.Expression;
-        parseFqnExprOrWith(astNode: ast.FqnExprOrWith): c4.FqnExpr.Any;
-        parseFqnExprWith(astNode: ast.FqnExprWith): c4.FqnExpr.Custom;
-        parseFqnExprOrWhere(astNode: ast.FqnExprOrWhere): c4.FqnExpr.OrWhere;
-        parseFqnExprWhere(astNode: ast.FqnExprWhere): c4.FqnExpr.Where;
-        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
-        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
-        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
-        parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
-        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): import("type-fest").Except<c4.RelationExpr.Custom["customRelation"], "expr">;
-        parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
-        parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
-        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
-        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
-        isValid: import("../../validation").IsValidFn;
-        readonly services: import("../..").LikeC4Services;
-        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
-        get project(): import("../../workspace").Project;
-        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: import("langium").AstNode): string;
-        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
-            [key: string]: string | string[];
-        } | undefined;
-        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
-        convertTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
-        parseTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
-        parseImageAlias(value: string): string | undefined;
-        parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
-        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
-        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseBaseProps(props: {
-            title?: ast.MarkdownOrString | undefined;
-            summary?: ast.MarkdownOrString | undefined;
-            description?: ast.MarkdownOrString | undefined;
-            technology?: ast.MarkdownOrString | undefined;
-        }, override?: {
-            title?: string | undefined;
-            summary?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }): {
-            title?: string;
-            summary?: c4.MarkdownOrString;
-            description?: c4.MarkdownOrString;
-            technology?: string;
-        };
-    };
-} & TBase;

package/dist/model/parser/ModelParser.js

@@ -1,209 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Copyright (c) 2023-2025 Denis Davydkov
-// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-//
-// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
-import { invariant, isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from '@likec4/core';
-import { exact, FqnRef } from '@likec4/core/types';
-import { loggable } from '@likec4/log';
-import { filter, first, isDefined, isEmpty, isTruthy, map, mapToObj, pipe } from 'remeda';
-import { ast, toRelationshipStyle, } from '../../ast';
-import { logger as mainLogger } from '../../logger';
-import { stringHash } from '../../utils/stringHash';
-const logger = mainLogger.getChild('ModelParser');
-function* streamModel(doc) {
-    const traverseStack = LinkedList.from(doc.parseResult.value.models.flatMap(m => m.elements));
-    const relations = [];
-    let el;
-    while ((el = traverseStack.shift())) {
-        if (ast.isRelation(el)) {
-            relations.push(el);
-            continue;
-        }
-        // Skip ExtendRelation as it doesn't have child elements
-        if (ast.isExtendRelation(el)) {
-            yield el;
-            continue;
-        }
-        if (el.body && 'elements' in el.body && el.body.elements && el.body.elements.length > 0) {
-            for (const child of el.body.elements) {
-                traverseStack.push(child);
-            }
-        }
-        yield el;
-    }
-    yield* relations;
-    return;
-}
-export function ModelParser(B) {
-    return class ModelParser extends B {
-        parseModel() {
-            const doc = this.doc;
-            for (const el of streamModel(doc)) {
-                try {
-                    if (ast.isElement(el)) {
-                        doc.c4Elements.push(this.parseElement(el));
-                        continue;
-                    }
-                    if (ast.isRelation(el)) {
-                        if (this.isValid(el)) {
-                            doc.c4Relations.push(this.parseRelation(el));
-                        }
-                        continue;
-                    }
-                    if (ast.isExtendElement(el)) {
-                        const parsed = this.parseExtendElement(el);
-                        if (parsed) {
-                            doc.c4ExtendElements.push(parsed);
-                        }
-                        continue;
-                    }
-                    if (ast.isExtendRelation(el)) {
-                        const parsed = this.parseExtendRelation(el);
-                        if (parsed) {
-                            doc.c4ExtendRelations.push(parsed);
-                        }
-                        continue;
-                    }
-                    nonexhaustive(el);
-                }
-                catch (e) {
-                    const astPath = this.getAstNodePath(el);
-                    const error = loggable(e);
-                    const message = e instanceof Error ? e.message : String(error);
-                    logger.warn(`Error on {eltype}: ${message}\n document: {path}\n astpath: {astPath}\n${error}`, {
-                        path: doc.uri.path,
-                        eltype: el.$type,
-                        astPath,
-                    });
-                }
-            }
-        }
-        parseElement(astNode) {
-            const isValid = this.isValid;
-            const id = this.resolveFqn(astNode);
-            const kind = nonNullable(astNode.kind.ref, 'Element kind is not resolved').name;
-            const tags = this.parseTags(astNode.body);
-            const style = this.parseElementStyle(astNode.body?.props);
-            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-            const astPath = this.getAstNodePath(astNode);
-            let [_title, _summary, _technology] = astNode.props ?? [];
-            const bodyProps = pipe(astNode.body?.props ?? [], filter(isValid), filter(ast.isElementStringProperty), mapToObj(p => [p.key, p.value]));
-            const { title, ...descAndTech } = this.parseBaseProps(bodyProps, {
-                title: _title,
-                summary: _summary,
-                technology: _technology,
-            });
-            const links = this.parseLinks(astNode.body);
-            return exact({
-                id,
-                kind,
-                astPath,
-                title: title ?? astNode.name,
-                metadata,
-                tags: tags ?? undefined,
-                ...(links && isNonEmptyArray(links) && { links }),
-                ...descAndTech,
-                style,
-            });
-        }
-        parseExtendElement(astNode) {
-            const id = this.resolveFqn(astNode);
-            const tags = this.parseTags(astNode.body);
-            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-            const astPath = this.getAstNodePath(astNode);
-            const links = this.parseLinks(astNode.body) ?? [];
-            if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
-                return null;
-            }
-            return exact({
-                id,
-                astPath,
-                metadata,
-                tags,
-                links: isNonEmptyArray(links) ? links : null,
-            });
-        }
-        parseExtendRelation(astNode) {
-            const source = this.parseFqnRef(astNode.source);
-            const target = this.parseFqnRef(astNode.target);
-            invariant(FqnRef.isModelRef(source) || FqnRef.isImportRef(source), 'Source must be a model reference');
-            invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), 'Target must be a model reference');
-            const tags = this.parseTags(astNode.body);
-            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-            const astPath = this.getAstNodePath(astNode);
-            const links = this.parseLinks(astNode.body) ?? [];
-            if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
-                return null;
-            }
-            // Generate a stable relation ID based on source, target, kind, and title
-            // This allows extends to match specific relations between elements
-            const kind = (astNode.kind ?? astNode.dotKind?.kind)?.ref?.name;
-            // Normalize title the same way as parseRelation does
-            const { title = '' } = this.parseBaseProps({}, { title: astNode.title });
-            const id = stringHash('extend-relation', FqnRef.flatten(source), FqnRef.flatten(target), kind ?? 'default', title);
-            return exact({
-                id,
-                astPath,
-                metadata,
-                tags,
-                links: isNonEmptyArray(links) ? links : null,
-            });
-        }
-        _resolveRelationSource(node) {
-            if (isDefined(node.source)) {
-                const source = this.parseFqnRef(node.source);
-                invariant(FqnRef.isModelRef(source) || FqnRef.isImportRef(source), 'Relation source must be a model reference');
-                return source;
-            }
-            if (ast.isElementBody(node.$container)) {
-                return {
-                    model: this.resolveFqn(node.$container.$container),
-                };
-            }
-            if (ast.isExtendElementBody(node.$container)) {
-                return {
-                    model: this.resolveFqn(node.$container.$container),
-                };
-            }
-            throw new Error('RelationRefError: Invalid container for sourceless relation');
-        }
-        parseRelation(astNode) {
-            const isValid = this.isValid;
-            const source = this._resolveRelationSource(astNode);
-            const target = this.parseFqnRef(astNode.target);
-            invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), 'Target must be a model reference');
-            const tags = this.parseTags(astNode) ?? this.parseTags(astNode.body);
-            const links = this.parseLinks(astNode.body);
-            const kind = (astNode.kind ?? astNode.dotKind?.kind)?.ref?.name;
-            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-            const astPath = this.getAstNodePath(astNode);
-            const bodyProps = pipe(astNode.body?.props ?? [], filter(ast.isRelationStringProperty), filter(p => isTruthy(p.value)), mapToObj(p => [p.key, p.value]));
-            const navigateTo = pipe(astNode.body?.props ?? [], filter(ast.isRelationNavigateToProperty), map(p => p.value.view.ref?.name), filter(isTruthy), first());
-            const { title = '', description, technology } = this.parseBaseProps(bodyProps, {
-                // inline props
-                title: astNode.title,
-                description: astNode.description,
-                technology: astNode.technology,
-            });
-            const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
-            const id = stringHash(astPath, source.model, target.model);
-            return exact({
-                id,
-                astPath,
-                source,
-                target,
-                title,
-                metadata,
-                kind,
-                tags: tags ?? undefined,
-                links: isNonEmptyArray(links) ? links : undefined,
-                navigateTo: navigateTo ? navigateTo : undefined,
-                description,
-                technology,
-                ...toRelationshipStyle(styleProp?.props, isValid),
-            });
-        }
-    };
-}

package/dist/model/parser/PredicatesParser.d.ts

@@ -1,75 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { ast } from '../../ast';
-import type { WithExpressionV2 } from './FqnRefParser';
-export type WithPredicates = ReturnType<typeof PredicatesParser>;
-export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBase): {
-    new (...args: any[]): {
-        parsePredicate(astNode: ast.ExpressionV2): c4.ModelExpression;
-        parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelFqnExpr.Any;
-        parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelFqnExpr.OrWhere;
-        parseElementExpression(astNode: ast.FqnExpr): c4.ModelFqnExpr;
-        parseElementPredicateWhere(astNode: ast.FqnExprWhere): c4.ModelFqnExpr.Where;
-        parseElementPredicateWith(astNode: ast.FqnExprWith): c4.ModelFqnExpr.Custom;
-        parseRelationPredicate(astNode: ast.RelationExprOrWith): c4.ModelRelationExpr.Any;
-        parseRelationPredicateOrWhere(astNode: ast.RelationExprOrWhere): c4.ModelRelationExpr.OrWhere;
-        parseRelationPredicateWhere(astNode: ast.RelationExprWhere): c4.ModelRelationExpr.Where;
-        parseRelationPredicateWith(astNode: ast.RelationExprWith): c4.ModelRelationExpr.Custom;
-        parseRelationExpression(astNode: ast.RelationExpr): c4.ModelRelationExpr;
-        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
-        parseExpressionV2(astNode: ast.ExpressionV2): c4.Expression;
-        parseFqnExprOrWith(astNode: ast.FqnExprOrWith): c4.FqnExpr.Any;
-        parseFqnExprWith(astNode: ast.FqnExprWith): c4.FqnExpr.Custom;
-        parseFqnExprOrWhere(astNode: ast.FqnExprOrWhere): c4.FqnExpr.OrWhere;
-        parseFqnExprWhere(astNode: ast.FqnExprWhere): c4.FqnExpr.Where;
-        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
-        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
-        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
-        parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
-        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): import("type-fest").Except<c4.RelationExpr.Custom["customRelation"], "expr">;
-        parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
-        parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
-        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
-        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
-        isValid: import("../../validation").IsValidFn;
-        readonly services: import("../..").LikeC4Services;
-        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
-        get project(): import("../../workspace").Project;
-        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: import("langium").AstNode): string;
-        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
-            [key: string]: string | string[];
-        } | undefined;
-        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
-        convertTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
-        parseTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
-        parseImageAlias(value: string): string | undefined;
-        parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
-        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
-        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseBaseProps(props: {
-            title?: ast.MarkdownOrString | undefined;
-            summary?: ast.MarkdownOrString | undefined;
-            description?: ast.MarkdownOrString | undefined;
-            technology?: ast.MarkdownOrString | undefined;
-        }, override?: {
-            title?: string | undefined;
-            summary?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }): {
-            title?: string;
-            summary?: c4.MarkdownOrString;
-            description?: c4.MarkdownOrString;
-            technology?: string;
-        };
-    };
-} & TBase;

package/dist/model/parser/PredicatesParser.js

@@ -1,45 +0,0 @@
-import { nonexhaustive } from '@likec4/core';
-import { ast } from '../../ast';
-export function PredicatesParser(B) {
-    return class PredicatesParser extends B {
-        parsePredicate(astNode) {
-            return this.parseExpressionV2(astNode);
-        }
-        parseElementPredicate(astNode) {
-            if (ast.isFqnExprWith(astNode)) {
-                return this.parseFqnExprWith(astNode);
-            }
-            if (ast.isFqnExprOrWhere(astNode)) {
-                return this.parseFqnExprOrWhere(astNode);
-            }
-            nonexhaustive(astNode);
-        }
-        parseElementPredicateOrWhere(astNode) {
-            return this.parseFqnExprOrWhere(astNode);
-        }
-        parseElementExpression(astNode) {
-            return this.parseFqnExpr(astNode);
-        }
-        parseElementPredicateWhere(astNode) {
-            return this.parseFqnExprWhere(astNode);
-        }
-        parseElementPredicateWith(astNode) {
-            return this.parseFqnExprWith(astNode);
-        }
-        parseRelationPredicate(astNode) {
-            return this.parseRelationExprOrWith(astNode);
-        }
-        parseRelationPredicateOrWhere(astNode) {
-            return this.parseRelationExprOrWhere(astNode);
-        }
-        parseRelationPredicateWhere(astNode) {
-            return this.parseRelationExprWhere(astNode);
-        }
-        parseRelationPredicateWith(astNode) {
-            return this.parseRelationExprWith(astNode);
-        }
-        parseRelationExpression(astNode) {
-            return this.parseRelationExpr(astNode);
-        }
-    };
-}

package/dist/model/parser/SpecificationParser.d.ts

@@ -1,53 +0,0 @@
-import * as c4 from '@likec4/core';
-import { ast } from '../../ast';
-import { type Base } from './Base';
-export declare function SpecificationParser<TBase extends Base>(B: TBase): {
-    new (...args: any[]): {
-        parseSpecification(): void;
-        parseElementSpecificationNode(specAst: ast.SpecificationElementKind): {
-            [key: c4.ElementKind]: c4.ElementSpecification;
-        };
-        parseElementSpecificationNode(specAst: ast.SpecificationDeploymentNodeKind): {
-            [key: c4.DeploymentKind]: c4.ElementSpecification;
-        };
-        isValid: import("../../validation").IsValidFn;
-        readonly services: import("../..").LikeC4Services;
-        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
-        get project(): import("../../workspace").Project;
-        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: import("langium").AstNode): string;
-        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
-            [key: string]: string | string[];
-        } | undefined;
-        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
-        convertTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
-        parseTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
-        parseImageAlias(value: string): string | undefined;
-        parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
-        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
-        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseBaseProps(props: {
-            title?: ast.MarkdownOrString | undefined;
-            summary?: ast.MarkdownOrString | undefined;
-            description?: ast.MarkdownOrString | undefined;
-            technology?: ast.MarkdownOrString | undefined;
-        }, override?: {
-            title?: string | undefined;
-            summary?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }): {
-            title?: string;
-            summary?: c4.MarkdownOrString;
-            description?: c4.MarkdownOrString;
-            technology?: string;
-        };
-    };
-} & TBase;

package/dist/model/parser/SpecificationParser.js

@@ -1,113 +0,0 @@
-import * as c4 from '@likec4/core';
-import { exact } from '@likec4/core';
-import { nonNullable } from '@likec4/core/utils';
-import { loggable } from '@likec4/log';
-import { filter, isNonNullish, isNullish, isTruthy, mapToObj, omitBy, pipe } from 'remeda';
-import { ast, parseMarkdownAsString, toRelationshipStyle } from '../../ast';
-import { serverLogger } from '../../logger';
-import { removeIndent } from './Base';
-const logger = serverLogger.getChild('SpecificationParser');
-export function SpecificationParser(B) {
-    return class SpecificationParser extends B {
-        parseSpecification() {
-            const { parseResult: { value: { specifications, }, }, c4Specification, } = this.doc;
-            const isValid = this.isValid;
-            for (const elementSpec of specifications.flatMap(s => s.elements.filter(isValid))) {
-                try {
-                    Object.assign(c4Specification.elements, this.parseElementSpecificationNode(elementSpec));
-                }
-                catch (e) {
-                    logger.warn(loggable(e));
-                }
-            }
-            for (const deploymentNodeSpec of specifications.flatMap(s => s.deploymentNodes.filter(isValid))) {
-                try {
-                    Object.assign(c4Specification.deployments, this.parseElementSpecificationNode(deploymentNodeSpec));
-                }
-                catch (e) {
-                    logger.warn(loggable(e));
-                }
-            }
-            const relations_specs = specifications.flatMap(s => s.relationships.filter(this.isValid));
-            for (const { kind, props } of relations_specs) {
-                try {
-                    const kindName = kind.name;
-                    if (!isTruthy(kindName)) {
-                        continue;
-                    }
-                    if (kindName in c4Specification.relationships) {
-                        logger.warn(`Relationship kind "${kindName}" is already defined`);
-                        continue;
-                    }
-                    const bodyProps = pipe(props.filter(ast.isSpecificationRelationshipStringProperty) ?? [], filter(p => this.isValid(p) && isNonNullish(p.value)), mapToObj(p => [p.key, removeIndent(parseMarkdownAsString(p.value))]), omitBy(isNullish));
-                    c4Specification.relationships[kindName] = {
-                        ...bodyProps,
-                        ...toRelationshipStyle(props.filter(ast.isRelationshipStyleProperty), this.isValid),
-                    };
-                }
-                catch (e) {
-                    logger.warn(loggable(e));
-                }
-            }
-            const tags_specs = specifications.flatMap(s => s.tags.filter(this.isValid));
-            for (const tagSpec of tags_specs) {
-                try {
-                    const tag = tagSpec.tag.name;
-                    const astPath = this.getAstNodePath(tagSpec.tag);
-                    const color = tagSpec.color && this.parseColorLiteral(tagSpec.color);
-                    if (tag in c4Specification.tags) {
-                        logger.warn(`Tag {tag} is already defined, skipping duplicate`, { tag });
-                        continue;
-                    }
-                    if (isTruthy(tag)) {
-                        c4Specification.tags[tag] = {
-                            astPath,
-                            ...(color ? { color } : {}),
-                        };
-                    }
-                }
-                catch (e) {
-                    logger.warn(loggable(e));
-                }
-            }
-            const colors_specs = specifications.flatMap(s => s.colors.filter(isValid));
-            for (const { name, color } of colors_specs) {
-                try {
-                    const colorName = name.name;
-                    if (colorName in c4Specification.colors) {
-                        logger.warn(`Custom color "${colorName}" is already defined`);
-                        continue;
-                    }
-                    c4Specification.colors[colorName] = {
-                        color: nonNullable(this.parseColorLiteral(color), `Color "${colorName}" is not valid`),
-                    };
-                }
-                catch (e) {
-                    logger.warn(loggable(e));
-                }
-            }
-        }
-        parseElementSpecificationNode(specAst) {
-            const { kind, props } = specAst;
-            const kindName = kind.name;
-            if (!isTruthy(kindName)) {
-                throw new Error('DeploymentNodeKind name is not resolved');
-            }
-            const tags = this.parseTags(specAst);
-            const style = this.parseElementStyle(props.find(ast.isElementStyleProperty));
-            const links = this.parseLinks(specAst);
-            const bodyProps = pipe(props.filter(ast.isSpecificationElementStringProperty) ?? [], filter(p => this.isValid(p)), mapToObj(p => [p.key, p.value]));
-            const baseProps = this.parseBaseProps(bodyProps);
-            const notation = removeIndent(parseMarkdownAsString(bodyProps.notation));
-            return {
-                [kindName]: exact({
-                    ...baseProps,
-                    notation,
-                    tags: tags ?? undefined,
-                    ...(links && c4.isNonEmptyArray(links) && { links }),
-                    style,
-                }),
-            };
-        }
-    };
-}

package/dist/model/parser/ValueConverter.d.ts

@@ -1,4 +0,0 @@
-import { type CstNode, type ValueType, DefaultValueConverter } from 'langium';
-export declare class LikeC4ValueConverter extends DefaultValueConverter {
-    protected runConverter(rule: any, input: string, cstNode: CstNode): ValueType;
-}

package/dist/model/parser/ValueConverter.js

@@ -1,12 +0,0 @@
-import { DefaultValueConverter, ValueConverter } from 'langium';
-export class LikeC4ValueConverter extends DefaultValueConverter {
-    runConverter(rule, input, cstNode) {
-        if (rule.name === 'MarkdownString') {
-            if ((input.startsWith('"""') && input.endsWith('"""')) || (input.startsWith(`'''`) && input.endsWith(`'''`))) {
-                input = input.slice(2, -2);
-            }
-            return ValueConverter.convertString(input);
-        }
-        return super.runConverter(rule, input, cstNode);
-    }
-}