@likec4/language-server 1.46.4 → 1.48.0

package/dist/model/parser/FqnRefParser.js

@@ -1,382 +0,0 @@
-import { invariant, nonexhaustive, nonNullable } from '@likec4/core';
-import { loggable } from '@likec4/log';
-import { AstUtils } from 'langium';
-import { isBoolean, isDefined, isNonNullish, isTruthy } from 'remeda';
-import { ast, parseAstOpacityProperty, parseAstSizeValue, parseMarkdownAsString, toColor } from '../../ast';
-import { serverLogger } from '../../logger';
-import { projectIdFrom } from '../../utils';
-import { importsRef, instanceRef } from '../../utils/fqnRef';
-import { createBinaryOperator, parseWhereClause } from '../model-parser-where';
-import { removeIndent } from './Base';
-const logger = serverLogger.getChild('ExpressionV2Parser');
-const location = (astNode) => {
-    const cst = astNode.$cstNode;
-    const position = cst ? `:${cst.range.start.line + 1}:${cst.range.start.character + 1}` : '';
-    return `${AstUtils.getDocument(astNode).uri.fsPath}${position}`;
-};
-export function ExpressionV2Parser(B) {
-    return class ExpressionV2Parser extends B {
-        parseFqnRef(astNode) {
-            const refValue = nonNullable(astNode.value?.ref, () => `FqnRef "${astNode.$cstNode?.text}" is empty at ${location(astNode)}`);
-            if (ast.isImported(refValue)) {
-                const fqnRef = {
-                    project: projectIdFrom(refValue),
-                    model: this.resolveFqn(nonNullable(refValue.imported.ref, `FqnRef is empty of imported: ${refValue.$cstNode?.text}`)),
-                };
-                this.doc.c4Imports.set(fqnRef.project, fqnRef.model);
-                return fqnRef;
-            }
-            if (ast.isElement(refValue)) {
-                const imported = importsRef(astNode);
-                if (imported) {
-                    const fqnRef = {
-                        project: projectIdFrom(imported),
-                        model: this.resolveFqn(refValue),
-                    };
-                    this.doc.c4Imports.set(fqnRef.project, fqnRef.model);
-                    return fqnRef;
-                }
-                const deployedInstanceAst = instanceRef(astNode);
-                if (!deployedInstanceAst) {
-                    return {
-                        model: this.resolveFqn(refValue),
-                    };
-                }
-                const deployment = this.resolveFqn(deployedInstanceAst);
-                const element = this.resolveFqn(refValue);
-                return {
-                    deployment,
-                    element,
-                };
-            }
-            if (ast.isDeploymentElement(refValue)) {
-                return {
-                    deployment: this.resolveFqn(refValue),
-                };
-            }
-            nonexhaustive(refValue);
-        }
-        parseExpressionV2(astNode) {
-            if (ast.isFqnExprOrWith(astNode)) {
-                return this.parseFqnExprOrWith(astNode);
-            }
-            if (ast.isRelationExprOrWith(astNode)) {
-                return this.parseRelationExprOrWith(astNode);
-            }
-            nonexhaustive(astNode);
-        }
-        parseFqnExprOrWith(astNode) {
-            if (ast.isFqnExprWith(astNode)) {
-                return this.parseFqnExprWith(astNode);
-            }
-            if (ast.isFqnExprOrWhere(astNode)) {
-                return this.parseFqnExprOrWhere(astNode);
-            }
-            nonexhaustive(astNode);
-        }
-        parseFqnExprWith(astNode) {
-            const expr = this.parseFqnExprOrWhere(astNode.subject);
-            const props = astNode.custom?.props ?? [];
-            return props.reduce((acc, prop) => {
-                if (!this.isValid(prop)) {
-                    return acc;
-                }
-                if (ast.isNavigateToProperty(prop)) {
-                    const viewId = prop.value.view.$refText;
-                    if (isTruthy(viewId)) {
-                        acc.custom.navigateTo = viewId;
-                    }
-                    return acc;
-                }
-                if (ast.isElementStringProperty(prop)) {
-                    if (isDefined(prop.value) && prop.key !== 'summary') {
-                        if (prop.key === 'description') {
-                            const parsed = this.parseMarkdownOrString(prop.value);
-                            if (parsed) {
-                                acc.custom['description'] = parsed;
-                            }
-                        }
-                        else {
-                            acc.custom[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) || '';
-                        }
-                    }
-                    return acc;
-                }
-                if (ast.isIconProperty(prop)) {
-                    const value = this.parseIconProperty(prop);
-                    if (isDefined(value)) {
-                        acc.custom[prop.key] = value;
-                    }
-                    return acc;
-                }
-                if (ast.isColorProperty(prop)) {
-                    const value = toColor(prop);
-                    if (isDefined(value)) {
-                        acc.custom[prop.key] = value;
-                    }
-                    return acc;
-                }
-                if (ast.isShapeProperty(prop)) {
-                    if (isDefined(prop.value)) {
-                        acc.custom[prop.key] = prop.value;
-                    }
-                    return acc;
-                }
-                if (ast.isBorderProperty(prop)) {
-                    if (isDefined(prop.value)) {
-                        acc.custom[prop.key] = prop.value;
-                    }
-                    return acc;
-                }
-                if (ast.isOpacityProperty(prop)) {
-                    if (isDefined(prop.value)) {
-                        acc.custom[prop.key] = parseAstOpacityProperty(prop);
-                    }
-                    return acc;
-                }
-                if (ast.isNotationProperty(prop)) {
-                    const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : undefined;
-                    if (value) {
-                        acc.custom[prop.key] = value;
-                    }
-                    return acc;
-                }
-                if (ast.isMultipleProperty(prop)) {
-                    if (isBoolean(prop.value)) {
-                        acc.custom[prop.key] = prop.value;
-                    }
-                    return acc;
-                }
-                if (ast.isShapeSizeProperty(prop)) {
-                    if (isTruthy(prop.value)) {
-                        acc.custom[prop.key] = parseAstSizeValue(prop);
-                    }
-                    return acc;
-                }
-                if (ast.isTextSizeProperty(prop)) {
-                    if (isTruthy(prop.value)) {
-                        acc.custom[prop.key] = parseAstSizeValue(prop);
-                    }
-                    return acc;
-                }
-                if (ast.isPaddingSizeProperty(prop)) {
-                    if (isTruthy(prop.value)) {
-                        acc.custom[prop.key] = parseAstSizeValue(prop);
-                    }
-                    return acc;
-                }
-                nonexhaustive(prop);
-            }, {
-                custom: {
-                    expr,
-                },
-            });
-        }
-        parseFqnExprOrWhere(astNode) {
-            if (ast.isFqnExprWhere(astNode)) {
-                return this.parseFqnExprWhere(astNode);
-            }
-            if (ast.isFqnExpr(astNode)) {
-                return this.parseFqnExpr(astNode);
-            }
-            nonexhaustive(astNode);
-        }
-        parseFqnExprWhere(astNode) {
-            invariant(!ast.isFqnExprWhere(astNode.subject), 'FqnExprWhere is not allowed as subject of FqnExprWhere');
-            return {
-                where: {
-                    expr: this.parseFqnExpr(astNode.subject),
-                    condition: astNode.where ? parseWhereClause(astNode.where) : {
-                        kind: { neq: '--always-true--' },
-                    },
-                },
-            };
-        }
-        parseFqnExpr(astNode) {
-            if (ast.isWildcardExpression(astNode)) {
-                return {
-                    wildcard: true,
-                };
-            }
-            if (ast.isElementKindExpression(astNode)) {
-                invariant(astNode.kind?.ref, 'ElementKindExpr kind is not resolved: ' + astNode.$cstNode?.text);
-                return {
-                    elementKind: astNode.kind.ref.name,
-                    isEqual: astNode.isEqual,
-                };
-            }
-            if (ast.isElementTagExpression(astNode)) {
-                invariant(astNode.tag.tag.ref, 'ElementTagExpr tag is not resolved: ' + astNode.$cstNode?.text);
-                let elementTag = astNode.tag.tag.$refText;
-                return {
-                    elementTag: elementTag,
-                    isEqual: astNode.isEqual,
-                };
-            }
-            if (ast.isFqnRefExpr(astNode)) {
-                return this.parseFqnRefExpr(astNode);
-            }
-            nonexhaustive(astNode);
-        }
-        parseFqnRefExpr(astNode) {
-            const ref = this.parseFqnRef(astNode.ref);
-            switch (true) {
-                case astNode.selector === '._':
-                    return {
-                        ref,
-                        selector: 'expanded',
-                    };
-                case astNode.selector === '.**':
-                    return {
-                        ref,
-                        selector: 'descendants',
-                    };
-                case astNode.selector === '.*':
-                    return {
-                        ref,
-                        selector: 'children',
-                    };
-                default:
-                    return { ref };
-            }
-        }
-        parseFqnExpressions(astNode) {
-            const exprs = [];
-            let iter = astNode;
-            while (iter) {
-                try {
-                    if (isNonNullish(iter.value) && this.isValid(iter.value)) {
-                        exprs.push(this.parseFqnExpr(iter.value));
-                    }
-                }
-                catch (e) {
-                    logger.warn(loggable(e));
-                }
-                iter = iter.prev;
-            }
-            return exprs.reverse();
-        }
-        parseRelationExprOrWith(astNode) {
-            if (ast.isRelationExprWith(astNode)) {
-                return this.parseRelationExprWith(astNode);
-            }
-            if (ast.isRelationExprOrWhere(astNode)) {
-                return this.parseRelationExprOrWhere(astNode);
-            }
-            nonexhaustive(astNode);
-        }
-        parseRelationExprWith(astNode) {
-            const expr = this.parseRelationExprOrWhere(astNode.subject);
-            const customProps = this.parseCustomRelationProperties(astNode.custom);
-            return {
-                customRelation: {
-                    ...customProps,
-                    expr,
-                },
-            };
-        }
-        parseCustomRelationProperties(custom) {
-            const props = custom?.props ?? [];
-            return props.reduce((acc, prop) => {
-                if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
-                    const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : undefined;
-                    if (value) {
-                        acc[prop.key] = value;
-                    }
-                    return acc;
-                }
-                if (ast.isArrowProperty(prop)) {
-                    if (isTruthy(prop.value)) {
-                        acc[prop.key] = prop.value;
-                    }
-                    return acc;
-                }
-                if (ast.isColorProperty(prop)) {
-                    const value = toColor(prop);
-                    if (isTruthy(value)) {
-                        acc[prop.key] = value;
-                    }
-                    return acc;
-                }
-                if (ast.isLineProperty(prop)) {
-                    if (isTruthy(prop.value)) {
-                        acc[prop.key] = prop.value;
-                    }
-                    return acc;
-                }
-                if (ast.isRelationNavigateToProperty(prop)) {
-                    const viewId = prop.value.view.ref?.name;
-                    if (isTruthy(viewId)) {
-                        acc[prop.key] = viewId;
-                    }
-                    return acc;
-                }
-                nonexhaustive(prop);
-            }, {});
-        }
-        parseRelationExprOrWhere(astNode) {
-            if (ast.isRelationExprWhere(astNode)) {
-                return this.parseRelationExprWhere(astNode);
-            }
-            if (ast.isRelationExpr(astNode)) {
-                return this.parseRelationExpr(astNode);
-            }
-            nonexhaustive(astNode);
-        }
-        parseRelationExprWhere(astNode) {
-            invariant(!ast.isRelationExprWhere(astNode.subject), 'RelationExprWhere is not allowed as subject of RelationExprWhere');
-            const relationOrWhereExpr = this.parseRelationExpr(astNode.subject);
-            const expr = relationOrWhereExpr.where?.expr ?? relationOrWhereExpr;
-            const kindCondition = relationOrWhereExpr.where?.condition;
-            const whereCondition = astNode.where ? parseWhereClause(astNode.where) : null;
-            let condition;
-            if (whereCondition && kindCondition) {
-                condition = createBinaryOperator('and', kindCondition, whereCondition);
-            }
-            else {
-                condition = whereCondition
-                    ?? kindCondition
-                    ?? { kind: { neq: '--always-true--' } };
-            }
-            return {
-                where: {
-                    expr: expr,
-                    condition: condition,
-                },
-            };
-        }
-        parseRelationExpr(astNode) {
-            switch (astNode.$type) {
-                case 'DirectedRelationExpr':
-                    return this.wrapInWhere({
-                        source: this.parseFqnExpr(astNode.source.from),
-                        target: this.parseFqnExpr(astNode.target),
-                        isBidirectional: astNode.source.isBidirectional,
-                    }, this.parseInlineKindCondition(astNode.source));
-                case 'InOutRelationExpr':
-                    return {
-                        inout: this.parseFqnExpr(astNode.inout.to),
-                    };
-                case 'OutgoingRelationExpr':
-                    return this.wrapInWhere({ outgoing: this.parseFqnExpr(astNode.from) }, this.parseInlineKindCondition(astNode));
-                case 'IncomingRelationExpr':
-                    return {
-                        incoming: this.parseFqnExpr(astNode.to),
-                    };
-                default:
-                    nonexhaustive(astNode);
-            }
-        }
-        parseInlineKindCondition(astNode) {
-            const kind = astNode.kind ?? astNode.dotKind?.kind;
-            if (kind) {
-                invariant(kind.ref, 'Kind is not resolved: ' + astNode.$cstNode?.text);
-                return { kind: { eq: kind.ref?.name } };
-            }
-            return null;
-        }
-        wrapInWhere(expr, condition) {
-            return condition ? { where: { expr, condition } } : expr;
-        }
-    };
-}

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

@@ -1,109 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { type ParsedAstGlobals, ast } from '../../ast';
-import type { WithViewsParser } from './ViewsParser';
-export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase): {
-    new (...args: any[]): {
-        parseGlobals(): void;
-        parseAndStoreGlobalPredicateGroupOrDynamic(astRule: ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup, id: c4.GlobalPredicateId, c4Globals: ParsedAstGlobals): void;
-        parseGlobalPredicateGroup(astRule: ast.GlobalPredicateGroup): c4.ElementViewPredicate[];
-        parseGlobalDynamicPredicateGroup(astRule: ast.GlobalDynamicPredicateGroup): c4.DynamicViewIncludeRule[];
-        parseGlobalStyleOrGroup(astRule: ast.GlobalStyle | ast.GlobalStyleGroup): c4.ElementViewRuleStyle[];
-        parseViews(): void;
-        parseElementView(astNode: ast.ElementView, additionalStyles: (c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>)[]): import("../../ast").ParsedAstElementView;
-        parseElementViewRule(astRule: ast.ViewRule): c4.ElementViewRule;
-        parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ElementViewPredicate;
-        parseViewRuleGlobalPredicateRef(astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef): c4.ViewRuleGlobalPredicateRef;
-        parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>;
-        parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ElementViewRuleGroup;
-        parseViewRuleRank(astRule: ast.ViewRuleRank): c4.ElementViewRuleRank;
-        parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ElementViewRuleStyle;
-        parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
-        parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: (c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>)[]): import("../../ast").ParsedAstDynamicView;
-        parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
-        parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
-        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicStepsParallel;
-        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicStep | c4.DynamicStepsSeries;
-        recursiveParseDynamicStepChain(node: ast.DynamicStepChain, callstack?: Array<[source: c4.Fqn, target: c4.Fqn]>): c4.DynamicStep[];
-        parseDynamicStepSingle(node: ast.DynamicStepSingle): c4.DynamicStep;
-        parseAbstractDynamicStep(astnode: ast.AbstractDynamicStep): import("type-fest").Writable<import("type-fest").Except<c4.DynamicStep, "source", {
-            requireExactProps: true;
-        }>>;
-        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;
-        };
-        parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
-        parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
-        parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewPredicate;
-        parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle;
-        parseDeployment(): void;
-        parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
-        parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
-        parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
-        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4.FqnRef;
-        parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
-    };
-} & TBase;

package/dist/model/parser/GlobalsParser.js

@@ -1,84 +0,0 @@
-import { nonexhaustive } from '@likec4/core';
-import { loggable } from '@likec4/log';
-import { hasAtLeast, isTruthy } from 'remeda';
-import { ast } from '../../ast';
-import { serverLogger } from '../../logger';
-const logger = serverLogger.getChild('GlobalsParser');
-export function GlobalsParser(B) {
-    return class GlobalsParser extends B {
-        parseGlobals() {
-            const { parseResult, c4Globals } = this.doc;
-            const isValid = this.isValid;
-            const globals = parseResult.value.globals.filter(isValid);
-            const elRelPredicates = globals.flatMap(r => r.predicates.filter(isValid));
-            for (const predicate of elRelPredicates) {
-                try {
-                    const globalPredicateId = predicate.name;
-                    if (!isTruthy(globalPredicateId)) {
-                        continue;
-                    }
-                    if (globalPredicateId in c4Globals.predicates) {
-                        logger.warn(`Global predicate named "${globalPredicateId}" is already defined`);
-                        continue;
-                    }
-                    this.parseAndStoreGlobalPredicateGroupOrDynamic(predicate, globalPredicateId, c4Globals);
-                }
-                catch (e) {
-                    logger.warn(loggable(e));
-                }
-            }
-            const styles = globals.flatMap(r => r.styles.filter(isValid));
-            for (const style of styles) {
-                try {
-                    const globalStyleId = style.id.name;
-                    if (!isTruthy(globalStyleId)) {
-                        continue;
-                    }
-                    if (globalStyleId in c4Globals.styles) {
-                        logger.warn(`Global style named "${globalStyleId}" is already defined`);
-                        continue;
-                    }
-                    const styles = this.parseGlobalStyleOrGroup(style);
-                    if (hasAtLeast(styles, 1)) {
-                        c4Globals.styles[globalStyleId] = styles;
-                    }
-                }
-                catch (e) {
-                    logger.warn(loggable(e));
-                }
-            }
-        }
-        parseAndStoreGlobalPredicateGroupOrDynamic(astRule, id, c4Globals) {
-            if (ast.isGlobalPredicateGroup(astRule)) {
-                const predicates = this.parseGlobalPredicateGroup(astRule);
-                if (hasAtLeast(predicates, 1)) {
-                    c4Globals.predicates[id] = predicates;
-                }
-                return;
-            }
-            if (ast.isGlobalDynamicPredicateGroup(astRule)) {
-                const predicates = this.parseGlobalDynamicPredicateGroup(astRule);
-                if (hasAtLeast(predicates, 1)) {
-                    c4Globals.dynamicPredicates[id] = predicates;
-                }
-                return;
-            }
-            nonexhaustive(astRule);
-        }
-        parseGlobalPredicateGroup(astRule) {
-            return astRule.predicates.map(p => this.parseViewRulePredicate(p));
-        }
-        parseGlobalDynamicPredicateGroup(astRule) {
-            return astRule.predicates.map(p => this.parseDynamicViewIncludePredicate(p));
-        }
-        parseGlobalStyleOrGroup(astRule) {
-            if (ast.isGlobalStyle(astRule)) {
-                return [this.parseViewRuleStyle(astRule)];
-            }
-            if (ast.isGlobalStyleGroup(astRule)) {
-                return astRule.styles.map(s => this.parseViewRuleStyle(s));
-            }
-            nonexhaustive(astRule);
-        }
-    };
-}

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

@@ -1,46 +0,0 @@
-import type { ast } from '../../ast';
-import type { Base } from './Base';
-export declare function ImportsParser<TBase extends Base>(B: TBase): {
-    new (...args: any[]): {
-        parseImports(): void;
-        isValid: import("../../validation").IsValidFn;
-        readonly services: import("../..").LikeC4Services;
-        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
-        get project(): import("../../workspace").Project;
-        resolveFqn(node: ast.FqnReferenceable): import("@likec4/core").Fqn;
-        getAstNodePath(node: import("langium").AstNode): string;
-        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
-            [key: string]: string | string[];
-        } | undefined;
-        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): import("@likec4/core").MarkdownOrString | undefined;
-        convertTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E | undefined): import("@likec4/core").NonEmptyArray<import("@likec4/core").Tag<string>> | null;
-        parseTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E): import("@likec4/core").NonEmptyArray<import("@likec4/core").Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): import("@likec4/core").Link[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): import("@likec4/core").Link[] | undefined;
-        parseIconProperty(prop: ast.IconProperty | undefined): import("@likec4/core").IconUrl | undefined;
-        parseImageAlias(value: string): string | undefined;
-        parseColorLiteral(astNode: ast.ColorLiteral): import("@likec4/core").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?: import("@likec4/core").MarkdownOrString;
-            description?: import("@likec4/core").MarkdownOrString;
-            technology?: string;
-        };
-    };
-} & TBase;

package/dist/model/parser/ImportsParser.js

@@ -1,24 +0,0 @@
-import { nonNullable } from '@likec4/core';
-import { loggable } from '@likec4/log';
-import { serverLogger } from '../../logger';
-const logger = serverLogger.getChild('ImportsParser');
-export function ImportsParser(B) {
-    return class ImportsParser extends B {
-        parseImports() {
-            const imports = this.doc.parseResult.value.imports ?? [];
-            for (const importsFromPoject of imports) {
-                const project = importsFromPoject.project;
-                let imported = importsFromPoject.imports;
-                while (imported) {
-                    try {
-                        this.doc.c4Imports.set(project, this.resolveFqn(nonNullable(imported.imported.ref, `ElementRef is empty of imported: ${imported.imported.$refText}`)));
-                    }
-                    catch (e) {
-                        logger.warn(loggable(e));
-                    }
-                    imported = imported.prev;
-                }
-            }
-        }
-    };
-}